From 16bd2457de0821c92509e1b3fe694ae10c300b8f Mon Sep 17 00:00:00 2001
From: Nikolay Ivanov <simply_nicky@VPN0037.desy.de>
Date: Tue, 13 Oct 2020 15:37:46 +0200
Subject: [PATCH] AbberationsFit implemented

---
 dev.ipynb                |  2045 -------
 st_sim/__init__.py       |     2 +-
 st_sim/__main__.py       |     1 +
 st_sim/bin/beam_calc.c   | 10620 +++++++++++++++++--------------------
 st_sim/bin/beam_calc.pyx |   225 +-
 st_sim/bin/st_utils.c    |  1280 ++---
 st_sim/bin/st_utils.pyx  |    19 +-
 st_sim/parameters.ini    |     5 +-
 st_sim/st_loader.py      |   331 +-
 st_sim/st_protocol.ini   |    14 +-
 st_sim/st_wrapper.py     |   188 +-
 test.py                  |    41 +-
 12 files changed, 6229 insertions(+), 8542 deletions(-)
 delete mode 100755 dev.ipynb
 mode change 100644 => 100755 st_sim/bin/beam_calc.c

diff --git a/dev.ipynb b/dev.ipynb
deleted file mode 100755
index 7fe5c90..0000000
--- a/dev.ipynb
+++ /dev/null
@@ -1,2045 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext cython\n",
-    "import speckle_tracking as st\n",
-    "import st_sim\n",
-    "from st_sim.bin import *\n",
-    "import h5py\n",
-    "import os\n",
-    "import numpy as np\n",
-    "import pickle\n",
-    "import concurrent.futures\n",
-    "import matplotlib.pyplot as plt\n",
-    "from multiprocessing import cpu_count\n",
-    "from scipy.ndimage import gaussian_filter, convolve1d\n",
-    "from scipy.integrate import quad\n",
-    "from scipy.optimize import least_squares"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def st_update(I_n, W, dij, basis, x_ps, y_ps, z, df, u_max=100, n_iter=5):\n",
-    "    \"\"\"\n",
-    "    Andrew's speckle tracking update algorithm\n",
-    "    \n",
-    "    I_n - measured data\n",
-    "    W - whitefield\n",
-    "    basis - detector plane basis vectors\n",
-    "    x_ps, y_ps - x and y pixel sizes\n",
-    "    z - distance between the sample and the detector\n",
-    "    df - defocus distance\n",
-    "    u_max - pixel mapping search window size\n",
-    "    n_iter - number of iterations\n",
-    "    \"\"\"\n",
-    "    M = np.ones((I_n.shape[1], I_n.shape[2]), dtype=bool)\n",
-    "    u, dij_pix, res = st.generate_pixel_map(W.shape, dij, basis, x_ps,\n",
-    "                                            y_ps, z, df, verbose=False)\n",
-    "    I0, n0, m0 = st.make_object_map(I_n, M, W, dij_pix, u, subpixel=True, verbose=False)\n",
-    "\n",
-    "    es = []\n",
-    "    for i in range(n_iter):\n",
-    "\n",
-    "        # calculate errors\n",
-    "        error_total = st.calc_error(I_n, M, W, dij_pix, I0, u, n0, m0, subpixel=True, verbose=False)[0]\n",
-    "\n",
-    "        # store total error\n",
-    "        es.append(error_total)\n",
-    "\n",
-    "        # update pixel map\n",
-    "        u = st.update_pixel_map(I_n, M, W, I0, u, n0, m0, dij_pix,\n",
-    "                                search_window=[1, u_max], subpixel=True,\n",
-    "                                fill_bad_pix=True, integrate=False,\n",
-    "                                quadratic_refinement=True, verbose=False)[0]\n",
-    "        u_max = int(np.max(np.abs(u - np.indices(W.shape))))\n",
-    "\n",
-    "        # make reference image\n",
-    "        I0, n0, m0 = st.make_object_map(I_n, M, W, dij_pix, u, subpixel=True, verbose=False)\n",
-    "\n",
-    "        # update translations\n",
-    "        dij_pix = st.update_translations(I_n, M, W, I0, u, n0, m0, dij_pix)[0]\n",
-    "    return {'u':u, 'I0':I0, 'errors':es}\n",
-    "\n",
-    "def pixel_translations(basis, dij, df, z):\n",
-    "    dij_pix = (basis * dij[:, None]).sum(axis=-1)\n",
-    "    dij_pix /= (basis**2).sum(axis=-1) * df / z\n",
-    "    dij_pix -= dij_pix.mean(axis=0)\n",
-    "    return np.ascontiguousarray(dij_pix[:, 0]), np.ascontiguousarray(dij_pix[:, 1])\n",
-    "\n",
-    "def str_update(I_n, W, dij, basis, x_ps, y_ps, z, df, u_max=100, n_iter=5, l_scale=2.5):\n",
-    "    \"\"\"\n",
-    "    Robust version of Andrew's speckle tracking update algorithm\n",
-    "    \n",
-    "    I_n - measured data\n",
-    "    W - whitefield\n",
-    "    basis - detector plane basis vectors\n",
-    "    x_ps, y_ps - x and y pixel sizes\n",
-    "    z - distance between the sample and the detector\n",
-    "    df - defocus distance\n",
-    "    u_max - pixel mapping search window size\n",
-    "    n_iter - number of iterations\n",
-    "    \"\"\"\n",
-    "    I_n = I_n.astype(np.float64)\n",
-    "    W = W.astype(np.float64)\n",
-    "    u = np.indices(W.shape, dtype=np.float64)\n",
-    "    di, dj = pixel_translations(basis, dij, df, z)\n",
-    "    dss, dfs = np.mean(di[1:] - di[:-1]), np.mean(dj[1:] - dj[:-1])\n",
-    "    I0, di, dj = make_reference(I_n, W, u, di, dj, l_scale)\n",
-    "\n",
-    "    es = []\n",
-    "    for i in range(n_iter):\n",
-    "\n",
-    "        # calculate errors\n",
-    "        es.append(total_mse(I_n, W, I0, u, di, dj))\n",
-    "\n",
-    "        # update pixel map\n",
-    "        u = update_pixel_map_search(I_n, W, I0, u, di, dj, dss, dfs, 1, u_max // 2)\n",
-    "        u_max = int(np.max(np.abs(u - np.indices(W.shape))))\n",
-    "        u = gaussian_filter(u, (0, 0, l_scale))\n",
-    "\n",
-    "        # make reference image\n",
-    "        I0, di, dj = make_reference(I_n, W, u, di, dj, l_scale)\n",
-    "    return {'u':u, 'I0':I0, 'errors':es}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def ab_model(pix, coeff):\n",
-    "    return coeff[0] + coeff[1] * (pix - coeff[3]) + coeff[2] * (pix - coeff[3])**2\n",
-    "\n",
-    "def ab_errors(coeff, data, weights):\n",
-    "    return weights * (ab_model(data[:, 0], coeff) - data[:, 1])\n",
-    "\n",
-    "def ph_model(theta, coeff):\n",
-    "    return coeff[0] + coeff[1] * (theta - coeff[4]) + \\\n",
-    "           coeff[2] * (theta - coeff[4])**2 + coeff[3] * (theta - coeff[4])**3\n",
-    "\n",
-    "def ph_errors(coeff, data):\n",
-    "    return ph_model(data[:, 0], coeff) - data[:, 1]\n",
-    "\n",
-    "def phase_fit(u, roi, x_ps, z, df, wl, u_var=1e-6, l_scale=5, max_order=4):\n",
-    "    # calculate the phase\n",
-    "    u_pix = (u - np.indices((u.shape[1], u.shape[2])))[1, 0, roi[0]:roi[1]]\n",
-    "    ang = u_pix * x_ps / z\n",
-    "    phase = np.cumsum(ang) * x_ps * df / z * 2 * np.pi / wl\n",
-    "    pix = np.arange(u.shape[2])[roi[0]:roi[1]]\n",
-    "    x, theta = pix * x_ps, pix * x_ps / z\n",
-    "\n",
-    "    data = np.stack((pix, gaussian_filter(u_pix, l_scale)), axis=-1)\n",
-    "    w = np.tanh(data[:, 1]**2 / u_var)\n",
-    "\n",
-    "    # find a min/max argument\n",
-    "    u0 = gaussian_filter(u_pix, u_pix.shape[0] / 10)\n",
-    "    if np.median(np.gradient(np.gradient(u0))) > 0:\n",
-    "        idx = np.argmin(u0)\n",
-    "    else:\n",
-    "        idx = np.argmax(u0)\n",
-    "\n",
-    "        \n",
-    "    # fit the model to the data\n",
-    "    bounds = ([-np.inf, -np.inf, -np.inf, 0],\n",
-    "              [np.inf, np.inf, np.inf, u_pix.shape[0]])\n",
-    "    fit = least_squares(ab_errors, np.array([0, 0, 0, pix[idx]]), args=(data, w),\n",
-    "                          xtol=1e-14, ftol=1e-14, bounds=bounds, loss='cauchy')\n",
-    "    ang_fit = np.array([fit.x[0], fit.x[1] / (x_ps / z),\n",
-    "                        fit.x[2] / (x_ps / z)**2, fit.x[3]]) * x_ps / z\n",
-    "    ph_fit = np.array([0, ang_fit[0], ang_fit[1] / 2, ang_fit[2] / 3]) * 2 * np.pi / wl * df\n",
-    "    ph_fit = np.concatenate((ph_fit, [ang_fit[-1]]))\n",
-    "    phase -= np.mean(phase - ph_model(theta, ph_fit))\n",
-    "\n",
-    "    # evaluating errors\n",
-    "    r_sq = 1 - np.sum(ab_errors(fit.x, data, w)**2) / np.sum((w * (data[:, 1] - data[:, 1].mean()))**2)\n",
-    "    return {'pix': pix, 'theta': theta, 'u_pix': u_pix, 'angles': ang, 'phase': phase,\n",
-    "            'fit': fit, 'ang_fit': ang_fit, 'ph_fit': ph_fit, 'r_sq': r_sq}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# dev"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%cython -c=-fopenmp -lgsl -lgslcblas -lomp -L=/usr/local/lib\n",
-    "#cython: language_level=3, boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True\n",
-    "cimport numpy as cnp\n",
-    "import numpy as np\n",
-    "cimport openmp\n",
-    "from cython_gsl cimport *\n",
-    "from libc.math cimport sqrt, cos, sin, exp, pi, erf, sinh, floor\n",
-    "from cython.parallel import prange, parallel\n",
-    "\n",
-    "ctypedef cnp.complex128_t complex_t\n",
-    "ctypedef cnp.float64_t float_t\n",
-    "ctypedef cnp.int64_t int_t\n",
-    "ctypedef cnp.uint64_t uint_t\n",
-    "ctypedef cnp.uint8_t uint8_t\n",
-    "DEF X_TOL = 4.320005384913445 # Y_TOL = 1e-9\n",
-    "DEF FLOAT_MAX = 1.7976931348623157e+308\n",
-    "\n",
-    "cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:\n",
-    "    cdef int_t m = l + (r - l) // 2\n",
-    "    if l <= r:\n",
-    "        if x == values[m]:\n",
-    "            return m\n",
-    "        elif x > values[m] and x <= values[m + 1]:\n",
-    "            return m + 1\n",
-    "        elif x < values[m]:\n",
-    "            return binary_search(values, l, m, x)\n",
-    "        else:\n",
-    "            return binary_search(values, m + 1, r, x)\n",
-    "\n",
-    "cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:\n",
-    "    cdef int_t r = values.shape[0]\n",
-    "    if x < values[0]:\n",
-    "        return 0\n",
-    "    elif x > values[r - 1]:\n",
-    "        return r\n",
-    "    else:\n",
-    "        return binary_search(values, 0, r, x)\n",
-    "\n",
-    "cdef void barcode_c(float_t[::1] br_tr, float_t[::1] x_arr, float_t[::1] bx_arr,\n",
-    "                     float_t sgm, float_t atn, float_t step) nogil:\n",
-    "    cdef:\n",
-    "        int_t a = x_arr.shape[0], b = bx_arr.shape[0], i, j0, j\n",
-    "        float_t br_dx = (bx_arr[b - 1] - bx_arr[0]) / b\n",
-    "        int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)\n",
-    "        float_t tr, xx, x0, x1\n",
-    "    for i in range(a):\n",
-    "        xx = x_arr[i] - x_arr[0] + step\n",
-    "        j0 = searchsorted(bx_arr, xx) # even '-', odd '+'\n",
-    "        tr = 0\n",
-    "        for j in range(j0 - bb, j0 + bb + 1):\n",
-    "            if j >= 1 and j < b:\n",
-    "                x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm\n",
-    "                x1 = (xx - bx_arr[j]) / sqrt(2) / sgm\n",
-    "                tr += 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))\n",
-    "        tr -= 0.25 * erf((xx - bx_arr[0]) / sqrt(2) / sgm)\n",
-    "        tr += 0.25 * erf((xx - bx_arr[b - 1]) / sqrt(2) / sgm)\n",
-    "        br_tr[i] = sqrt(1 + atn * tr)\n",
-    "\n",
-    "def barcode_1d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn):\n",
-    "    \"\"\"\n",
-    "    Barcode transmission array for a scan\n",
-    "\n",
-    "    x_arr - coordinates [um]\n",
-    "    bx_arr - bar coordinates array [um]\n",
-    "    sgm - bar haziness width [um]\n",
-    "    atn - bar attenuation (0.0 - 1.0)\n",
-    "    ss - scan step size [um]\n",
-    "    nf - number of frames of a scan\n",
-    "    \"\"\"\n",
-    "    cdef:\n",
-    "        int_t a = x_arr.shape[0]\n",
-    "        float_t[::1] br_tr = np.empty(a, dtype=np.float64)\n",
-    "    barcode_c(br_tr, x_arr, bx_arr, sgm, atn, 0)\n",
-    "    return np.asarray(br_tr)\n",
-    "        \n",
-    "def barcode_2d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn, float_t ss, int_t nf):\n",
-    "    \"\"\"\n",
-    "    Barcode transmission array for a scan\n",
-    "\n",
-    "    x_arr - coordinates [um]\n",
-    "    bx_arr - bar coordinates array [um]\n",
-    "    sgm - bar haziness width [um]\n",
-    "    atn - bar attenuation (0.0 - 1.0)\n",
-    "    ss - scan step size [um]\n",
-    "    nf - number of frames of a scan\n",
-    "    \"\"\"\n",
-    "    cdef:\n",
-    "        int_t a = x_arr.shape[0], i\n",
-    "        float_t[:, ::1] br_tr = np.empty((nf, a), dtype=np.float64)\n",
-    "    for i in range(nf):\n",
-    "        barcode_c(br_tr[i], x_arr, bx_arr, sgm, atn, i * ss)\n",
-    "    return np.asarray(br_tr)\n",
-    "\n",
-    "cdef float_t bprd_varc(float_t br_dx, float_t sgm, float_t atn) nogil:\n",
-    "    cdef:\n",
-    "        int_t a = <int_t>(br_dx / sgm + 1), i, n\n",
-    "        float_t var = 0\n",
-    "    for i in range(-a, a):\n",
-    "        n = 1 + 2 * i\n",
-    "        var += (atn * sin(pi * n / 2)**2 / pi / n)**2 * exp(-(pi * sgm * n / br_dx)**2)\n",
-    "    return var\n",
-    "\n",
-    "cdef float_t bnprd_varc(float_t br_dx, float_t sgm, float_t atn) nogil:\n",
-    "    cdef:\n",
-    "        float_t br_rt = br_dx / 2 / sgm\n",
-    "        float_t exp_term = 4 * exp(-br_rt**2 / 4) - exp(-br_rt**2) - 3\n",
-    "    return atn**2 / 4 * (2 * erf(br_rt / 2) - erf(br_rt) + exp_term / sqrt(pi) / br_rt)\n",
-    "\n",
-    "def bprd_var(float_t br_dx, float_t[::1] sgm_arr, float_t atn):\n",
-    "    cdef:\n",
-    "        int_t a = sgm_arr.shape[0], i\n",
-    "        float_t[::1] var_arr = np.empty(a, dtype=np.float64)\n",
-    "    for i in range(a):\n",
-    "        var_arr[i] = bprd_varc(br_dx, sgm_arr[i], atn)\n",
-    "    return np.asarray(var_arr)\n",
-    "\n",
-    "def bnprd_var(float_t br_dx, float_t[::1] sgm_arr, float_t atn):\n",
-    "    cdef:\n",
-    "        int_t a = sgm_arr.shape[0], i\n",
-    "        float_t[::1] var_arr = np.empty(a, dtype=np.float64)\n",
-    "    for i in range(a):\n",
-    "        var_arr[i] = bnprd_varc(br_dx, sgm_arr[i], atn)\n",
-    "    return np.asarray(var_arr)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'defoc': 400.0, 'det_dist': 2000000.0, 'step_size': 0.1, 'n_frames': 300, 'fs_size': 2000, 'ss_size': 1000, 'pix_size': 55.0, 'p0': 7000.0, 'wl': 7.29e-05, 'th_s': 0.0002, 'ap_x': 40.0, 'ap_y': 2.0, 'focus': 1500.0, 'alpha': -0.05, 'bar_size': 1, 'bar_sigma': 0.1, 'attenuation': 0.25, 'random_dev': 0.6, 'verbose': False}\n"
-     ]
-    }
-   ],
-   "source": [
-    "params = st_sim.parameters(bar_size = 1, bar_sigma = 0.1, attenuation=0.25, p0 = 7e3)\n",
-    "\n",
-    "globals().update(**params.export_dict())\n",
-    "print(params)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 488,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_x = int(1.6 * ap_x / focus * defoc * fs_size * pix_size / wl / det_dist)\n",
-    "n_y = int(1.2 * ap_y * ss_size * pix_size / wl / det_dist)\n",
-    "x_arr = np.linspace(-0.8 * ap_x / focus * defoc, 0.8 * ap_x / focus * defoc, n_x)\n",
-    "y_arr = np.linspace(-0.6 * ap_y, 0.6 * ap_y, n_y)\n",
-    "xx_arr = pix_size * np.arange(-fs_size // 2, fs_size // 2)\n",
-    "yy_arr = pix_size * np.arange(-ss_size // 2, ss_size // 2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 489,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "12876 905\n"
-     ]
-    }
-   ],
-   "source": [
-    "wf0_x = lens(x_arr, wl, ap_x, focus, defoc, alpha)\n",
-    "wf0_y = aperture(y_arr, focus + defoc, wl, ap_y)\n",
-    "wf1_y = fraunhofer_1d(wf0_y, y_arr, yy_arr, det_dist, wl)\n",
-    "print(n_x, n_y)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 490,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(x_arr, np.abs(wf0_x)**2)\n",
-    "axes[0].set_ylabel('Intensity, [a.u.]', fontsize=20)\n",
-    "axes[1].plot(x_arr, np.unwrap(np.angle(wf0_x)))\n",
-    "axes[1].set_ylabel('Phase, [rad]', fontsize=20)\n",
-    "for ax in axes:\n",
-    "    ax.set_xlabel('x coordinate, [um]', fontsize=20)\n",
-    "plt.tight_layout(h_pad=0.2)\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/wf0_x.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 491,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[-4.54938826  5.64273054]\n"
-     ]
-    }
-   ],
-   "source": [
-    "fx_lim = np.array([-0.45 * ap_x / focus, 0.5 * ap_x / focus])\n",
-    "th_lim = fx_lim - wl / 2 / np.pi * alpha * 3e9 * fx_lim**2 / defoc\n",
-    "print(th_lim * defoc)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 492,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "398.77099543001054 -0.048130831073207495\n"
-     ]
-    }
-   ],
-   "source": [
-    "beam_span = np.clip(th_lim * defoc, x_arr[0], x_arr[-1])\n",
-    "wf0_roi = ((beam_span - x_arr[0]) // (x_arr[1] - x_arr[0])).astype(np.int)\n",
-    "xr_arr = x_arr[wf0_roi[0]:wf0_roi[1]]\n",
-    "wf0_ph = np.unwrap(np.angle(wf0_x))\n",
-    "wf0_ph_fc = np.polyfit(xr_arr, wf0_ph[wf0_roi[0]:wf0_roi[1]], 3)\n",
-    "df_fit = np.pi / wl / wf0_ph_fc[1]\n",
-    "alpha_fit = wf0_ph_fc[0] * df_fit**3 * 1e-9\n",
-    "wf0_ph_fit = np.pi * xr_arr**2 / wl / df_fit + alpha_fit * 1e9 * (xr_arr / df_fit)**3 + wf0_ph[np.searchsorted(x_arr, 0)]\n",
-    "wf0_ph_th = np.pi * xr_arr**2 / wl / defoc + alpha * 1e9 * (xr_arr / defoc)**3 + wf0_ph[np.searchsorted(x_arr, 0)]\n",
-    "print(df_fit, alpha_fit)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 493,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(x_arr, np.abs(wf0_x)**2)\n",
-    "axes[0].set_ylabel('Intensity, [a.u.]', fontsize=20)\n",
-    "axes[1].plot(xr_arr, wf0_ph[wf0_roi[0]:wf0_roi[1]], label='Actual phase', color='b')\n",
-    "axes[1].plot(xr_arr, wf0_ph_fit, color='b', label='Third order polynomial', linestyle='dashed')\n",
-    "axes[1].plot(xr_arr, wf0_ph_th, color='r', label='Theoretical phase')\n",
-    "axes[1].set_ylabel('Phase, [rad]', fontsize=20)\n",
-    "axes[1].legend(fontsize=15)\n",
-    "for ax in axes:\n",
-    "    ax.set_xlabel('x coordinate, [um]', fontsize=20)\n",
-    "plt.tight_layout(h_pad=0.2)\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/wf0_phase_2.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 494,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "bsteps = barcode_steps(x_arr[-1] - x_arr[0], bar_size, random_dev, step_size, n_frames)\n",
-    "bs_t = barcode_2d(x_arr, bsteps, bar_sigma, attenuation, step_size, n_frames)\n",
-    "wf1_x = fraunhofer_2d(wf0_x * bs_t, x_arr, xx_arr, det_dist, wl)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 495,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(12, 6))\n",
-    "axes[0].plot(y_arr, np.abs(wf0_y)**2)\n",
-    "axes[1].plot(yy_arr, np.abs(wf1_y)**2)\n",
-    "axes[1].plot(yy_arr, (ap_y * np.sinc(np.pi * ap_y * yy_arr / wl / (det_dist + focus + defoc)))**2, alpha=0.2)\n",
-    "axes[0].set_title(\"Sample's plane\", fontsize=25)\n",
-    "axes[1].set_title(\"Detector's plane\", fontsize=25)\n",
-    "for ax in axes:\n",
-    "    ax.set_xlabel('y coordinate, [um]', fontsize=20)\n",
-    "    ax.set_ylabel('Intensity, a.u.', fontsize=20)\n",
-    "plt.tight_layout(w_pad=1.)\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/beam_x.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 496,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1008x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(14, 6))\n",
-    "axes[0].plot(x_arr, np.abs(wf0_x)**2)\n",
-    "axes[1].plot(xx_arr, np.abs(wf1_x[10])**2)\n",
-    "axes[0].set_title(\"Sample's plane\", fontsize=25)\n",
-    "axes[1].set_title(\"Detector's plane\", fontsize=25)\n",
-    "for ax in axes:\n",
-    "    ax.set_xlabel('x coordinate, [um]', fontsize=20)\n",
-    "    ax.set_ylabel('Intensity, a.u.', fontsize=20)\n",
-    "plt.tight_layout(w_pad=1.)\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/beam_x.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 497,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "6.314768986210761\n"
-     ]
-    }
-   ],
-   "source": [
-    "fx_lim = np.array([-0.5 * ap_x / focus, 0.5 * ap_x / focus])\n",
-    "th_lim = fx_lim - wl / 2 / np.pi * alpha * 3e9 * fx_lim**2 / (det_dist + defoc)\n",
-    "pdet = p0 * (1 - attenuation / 2) \n",
-    "ppix = pdet * pix_size / (np.tan(th_lim)[1] - np.tan(th_lim)[0]) / (det_dist + defoc)\n",
-    "print(ppix)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 498,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sigma = th_s * defoc\n",
-    "sx_arr = pix_size * np.arange(-np.ceil(4 * sigma / pix_size), np.ceil(4 * sigma / pix_size) + 1)\n",
-    "s_arr = np.exp(-sx_arr**2 / 2 / sigma**2)\n",
-    "s_arr /= s_arr.sum()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 499,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(300, 1, 2000) 6.182084678866165 2.608659607396254 1.0491798444211506\n"
-     ]
-    }
-   ],
-   "source": [
-    "det_c = 1 / wl**2 / (focus + defoc) / det_dist\n",
-    "i0 = p0 / ap_x / ap_y\n",
-    "data = make_frames(i_x=i0 * np.abs(wf1_x * det_c)**2, i_y=(np.abs(wf1_y)**2).sum() * np.ones(1),\n",
-    "                   sc_x=s_arr, sc_y=np.ones(1), pix_size=pix_size)\n",
-    "beam_span = np.tan(th_lim) * (det_dist + defoc)\n",
-    "x_roi = np.clip((beam_span - xx_arr.min()) // pix_size, 0, fs_size).astype(np.int)\n",
-    "roi = (data.shape[1] // 2, data.shape[1] // 2 + 1, x_roi[0], x_roi[1])\n",
-    "ptych = data[:, :, roi[2]:roi[3]].sum(axis=1)\n",
-    "mask = np.ones((data.shape[1], data.shape[2]), dtype=np.uint8)\n",
-    "whitefield = make_whitefield(data, mask)\n",
-    "print(data.shape, np.mean(ptych[..., 20:-20]), np.std(ptych[..., 20:-20]),\n",
-    "      np.std(ptych[..., 20:-20]) / np.sqrt(np.mean(ptych[..., 20:-20])))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 500,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, ax = plt.subplots(figsize=(15, 6))\n",
-    "ax.imshow(ptych[..., 20:-20])\n",
-    "ax.set_title('Ptychograph', fontsize=20)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 501,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, ax = plt.subplots(figsize=(10, 6))\n",
-    "ax.hist(ptych.ravel(), min(int(ptych.max() - ptych.min()), 100))\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 502,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "st_params = st_sim.STParams.import_dict(**globals())\n",
-    "ini_parser = st_params.export_ini()\n",
-    "with open('results/test/parameters.ini', 'w') as file:\n",
-    "    ini_parser.write(file)\n",
-    "    \n",
-    "st_converter = st_sim.STConverter()\n",
-    "st_converter.save(data, st_params, 'results/test', roi=roi)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# st_sim"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Iteration No. 1: MSE = 0.92891\n",
-      "Iteration No. 1: Search window size = 38\n",
-      "Iteration No. 2: MSE = 0.91080\n",
-      "Iteration No. 2: Search window size = 40\n",
-      "Iteration No. 3: MSE = 0.91019\n",
-      "Iteration No. 3: Search window size = 41\n",
-      "Iteration No. 4: MSE = 0.91017\n",
-      "Iteration No. 4: Search window size = 41\n",
-      "Iteration No. 5: MSE = 0.91017\n",
-      "Iteration No. 5: Search window size = 41\n"
-     ]
-    }
-   ],
-   "source": [
-    "st_loader = st_sim.loader()\n",
-    "st_data = st_loader.load('results/test/data.cxi')\n",
-    "st_data = st_data.change_defocus(0.00042)\n",
-    "st_1d = st_data.st_process().crop_data([0, 1, 50, 969])\n",
-    "st_res, errors = st_1d.iter_update(wfs=200, n_iter=5, l_scale=6.)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(298, 1, 969)"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "st_1d.data.shape, st_1d."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(st_res.ref_img[0])\n",
-    "axes[1].plot((st_res.pix_map - np.indices(st_res.whitefield.shape))[1, 0])\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data_dir = 'results/test'\n",
-    "with h5py.File(os.path.join(data_dir, 'data.cxi'), 'r') as cxi_file:\n",
-    "    roi = cxi_file['/speckle_tracking/roi'][...]\n",
-    "    I_n = cxi_file['/entry_1/data_1/data'][:, :, roi[2]:roi[3]].sum(axis=1)[:, None]\n",
-    "    M = cxi_file['/speckle_tracking/mask'][roi[0]:roi[1], roi[2]:roi[3]]\n",
-    "    W = cxi_file['/speckle_tracking/whitefield'][roi[0]:roi[1], roi[2]:roi[3]]\n",
-    "    basis = cxi_file['/entry_1/instrument_1/detector_1/basis_vectors'][...]\n",
-    "    z = cxi_file['/entry_1/instrument_1/detector_1/distance'][...]\n",
-    "    x_ps = cxi_file['/entry_1/instrument_1/detector_1/x_pixel_size'][...]\n",
-    "    y_ps = cxi_file['/entry_1/instrument_1/detector_1/y_pixel_size'][...]\n",
-    "    wl = cxi_file['/entry_1/instrument_1/source_1/wavelength'][...]\n",
-    "    dij = cxi_file['/entry_1/sample_1/geometry/translations'][...]\n",
-    "    df = cxi_file['/speckle_tracking/defocus'][...]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, ax = plt.subplots(figsize=(10, 5))\n",
-    "ax.imshow(I_n[:, 0])\n",
-    "ax.set_title('Ptychograph', fontsize=20)\n",
-    "ax.tick_params(axis='both', which='major', labelsize=15)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/ptycho.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "28 0.00038678518249739865\n"
-     ]
-    }
-   ],
-   "source": [
-    "params = st_sim.parameters()\n",
-    "\n",
-    "fx = params.ap_x / 2 / params.focus\n",
-    "z_bar = params.defoc * params.det_dist / (params.defoc + params.det_dist)\n",
-    "th_max = abs(params.wl / 2 / np.pi * params.alpha * 3e9 * fx**2 / (params.defoc + z_bar))\n",
-    "sw_max = max(int(2 * th_max / params.pix_size * params.det_dist), 10)\n",
-    "print(sw_max, th_max)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "building object map: 100%|██████████| 300/300 [00:00<00:00, 3493.12it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "#---------------------------\n",
-    "# Initialise\n",
-    "#---------------------------\n",
-    "\n",
-    "# generate pixel map\n",
-    "u, dij_pix, res = st.generate_pixel_map(W.shape, dij, basis, x_ps, y_ps, z, df, verbose=False)\n",
-    "di, dj = pixel_translations(basis, dij, df, z)\n",
-    "\n",
-    "# make reference image\n",
-    "I0, n0, m0 = st.make_object_map(I_n, M, W, dij_pix, u, subpixel=True)\n",
-    "\n",
-    "I0_gk, di, dj = make_reference(I_n.astype(np.float64), W.astype(np.float64), u, di, dj, ls=8.)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "4.896835718301136\n"
-     ]
-    }
-   ],
-   "source": [
-    "K = I_n.shape[-1] / (dij_pix[0, 1] - dij_pix[1, 1])\n",
-    "N = I_n.shape[0]\n",
-    "dI0 = np.gradient(I0_gk[0])\n",
-    "dI0_avg = np.mean(dI0**2)\n",
-    "p_var = np.mean(I_n)\n",
-    "print(np.sqrt((p_var / N + p_var / N / K) / dI0_avg / np.mean(I_n**2)))\n",
-    "# print(np.median((ph_res['u_pix'] - gaussian_filter(ph_res['u_pix'], 20))**2)**0.5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, ax = plt.subplots(figsize=(10, 6))\n",
-    "ax.plot(I0[0])\n",
-    "ax.plot(I0_gk[0])\n",
-    "ax.set_ylim(0, 2)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 200,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "calculating errors: 100%|██████████| 300/300 [00:00<00:00, 3959.93it/s]\n",
-      "building object map: 100%|██████████| 300/300 [00:00<00:00, 2960.21it/s]\n",
-      "updating pixel map: 9.01e-01: 100%|██████████| 10/10 [00:00<00:00, 29.68it/s]\n",
-      "updating object map and translations: 2.67e+02:   1%|          | 1/100 [00:00<00:22,  4.45it/s]\n",
-      "calculating errors: 100%|██████████| 300/300 [00:00<00:00, 4193.74it/s]\n",
-      "building object map: 100%|██████████| 300/300 [00:00<00:00, 3699.72it/s]\n",
-      "updating pixel map: 8.90e-01: 100%|██████████| 10/10 [00:00<00:00, 52.57it/s]\n",
-      "updating object map and translations: 2.66e+02:   1%|          | 1/100 [00:00<00:20,  4.93it/s]\n",
-      "calculating errors: 100%|██████████| 300/300 [00:00<00:00, 4446.21it/s]\n",
-      "building object map: 100%|██████████| 300/300 [00:00<00:00, 3723.83it/s]\n",
-      "updating pixel map: 8.87e-01: 100%|██████████| 10/10 [00:00<00:00, 39.00it/s]\n",
-      "updating object map and translations: 2.65e+02:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 300/300 [00:00<00:00, 4566.97it/s]\n",
-      "building object map: 100%|██████████| 300/300 [00:00<00:00, 3687.00it/s]\n",
-      "updating pixel map: 8.85e-01: 100%|██████████| 10/10 [00:00<00:00, 27.22it/s]\n",
-      "updating object map and translations: 2.65e+02:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 300/300 [00:00<00:00, 4484.83it/s]\n",
-      "building object map: 100%|██████████| 300/300 [00:00<00:00, 3489.76it/s]\n",
-      "updating pixel map: 8.84e-01: 100%|██████████| 10/10 [00:00<00:00, 20.10it/s]\n",
-      "updating object map and translations: 2.65e+02:   0%|          | 0/100 [00:00<?, ?it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "st_res = st_update(I_n, W, dij, basis, x_ps, y_ps, z, df)\n",
-    "ph_res = phase_fit(st_res['u'], (50, I_n.shape[-1] - 50), x_ps, z, df, wl)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 201,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(st_res['I0'][0])\n",
-    "axes[0].set_title('Reference image', fontsize=20)\n",
-    "axes[1].plot(ph_res['pix'], ph_res['u_pix'])\n",
-    "axes[1].plot(ph_res['pix'], ab_model(ph_res['pix'], ph_res['fit'].x), color='red')\n",
-    "axes[1].plot(ph_res['pix'], gaussian_filter(ph_res['u_pix'], 20))\n",
-    "axes[1].set_title('Pixel map', fontsize=20)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/st_results_simold.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 202,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(ph_res['theta'], ph_res['angles'])\n",
-    "axes[0].plot(ph_res['theta'], ab_model(ph_res['theta'], ph_res['ang_fit']),\n",
-    "             label='2nd order coeff = {:.3f} rad/rad^2'.format(ph_res['ang_fit'][2]))\n",
-    "axes[0].set_title('Deflection angles', fontsize=20)\n",
-    "axes[1].plot(ph_res['theta'], ph_res['phase'])\n",
-    "axes[1].plot(ph_res['theta'], ph_model(ph_res['theta'], ph_res['ph_fit']),\n",
-    "             label='3rd order coeff = {:.3f} rad/mrad^3'.format(ph_res['ph_fit'][3] * 1e-9))\n",
-    "axes[1].set_title('Phase', fontsize=20)\n",
-    "for ax in axes:\n",
-    "    ax.tick_params(axis='both', which='major', labelsize=12)\n",
-    "    ax.legend(fontsize=12)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/st_fits_simold.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "str_res = str_update(I_n, W, dij, basis, x_ps, y_ps, z, df)\n",
-    "phr_res = phase_fit(str_res['u'], (0, I_n.shape[-1]), x_ps, z, df, wl)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(str_res['I0'][0])\n",
-    "axes[0].set_title('Reference image', fontsize=20)\n",
-    "axes[1].plot(phr_res['pix'], phr_res['u_pix'])\n",
-    "axes[1].plot(phr_res['pix'], ab_model(phr_res['pix'], phr_res['fit'].x), color='red')\n",
-    "axes[1].set_title('Pixel map', fontsize=20)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/st_results_simnew.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 132,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(phr_res['theta'], phr_res['angles'])\n",
-    "axes[0].plot(phr_res['theta'], ab_model(phr_res['theta'], phr_res['ang_fit']),\n",
-    "             label='2nd order coeff = {:.3f} rad/rad^2'.format(phr_res['ang_fit'][2]))\n",
-    "axes[0].set_title('Deflection angles', fontsize=20)\n",
-    "axes[1].plot(phr_res['theta'], phr_res['phase'])\n",
-    "axes[1].plot(phr_res['theta'], ph_model(phr_res['theta'], phr_res['ph_fit']),\n",
-    "             label='3rd order coeff = {:.3f} rad/mrad^3'.format(phr_res['ph_fit'][3] * 1e-9))\n",
-    "axes[1].set_title('Phase', fontsize=20)\n",
-    "for ax in axes:\n",
-    "    ax.tick_params(axis='both', which='major', labelsize=12)\n",
-    "    ax.legend(fontsize=12)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/st_fits_simnew.pdf')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Experiment results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "u_dict, o_dict, ph_dict, th_dict = {}, {}, {}, {}\n",
-    "uf_dict, phf_dict, data_dict, r_dict = {}, {}, {}, {}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 177,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "roi_dict = {1511: (0, 1, 340, 1230), 1512: (0, 1, 340, 1230), 1513: (0, 1, 340, 1230), 1595: (0, 1, 360, 1050),\n",
-    "            1596: (0, 1, 360, 1050), 1597: (0, 1, 360, 1050), 1598: (0, 1, 360, 1050), 1654: (0, 1, 360, 1050),\n",
-    "            1670: (0, 1, 300, 1440), 1723: (0, 1, 370, 1195), 1727: (0, 1, 370, 1195)}\n",
-    "filename = 'Scan_{:d}.cxi'\n",
-    "exp_dir = 'results/exp'\n",
-    "scan_num = 1723\n",
-    "\n",
-    "with h5py.File(os.path.join(exp_dir, filename.format(scan_num)), 'r') as cxi_file:\n",
-    "    roi = roi_dict[scan_num]\n",
-    "    I_n = cxi_file['/entry_1/data_1/data'][:, roi[0]:roi[1], roi[2]:roi[3]]\n",
-    "    basis = cxi_file['/entry_1/instrument_1/detector_1/basis_vectors'][...]\n",
-    "    z = cxi_file['/entry_1/instrument_1/detector_1/distance'][...]\n",
-    "    x_ps = cxi_file['/entry_1/instrument_1/detector_1/x_pixel_size'][...]\n",
-    "    y_ps = cxi_file['/entry_1/instrument_1/detector_1/y_pixel_size'][...]\n",
-    "    wl = cxi_file['/entry_1/instrument_1/source_1/wavelength'][...]\n",
-    "    dij = cxi_file['/entry_1/sample_1/geometry/translation'][...]\n",
-    "\n",
-    "df = 0.5e-4\n",
-    "I_n = I_n.astype(np.float32).sum(axis=1)[:, None]\n",
-    "dij = dij\n",
-    "basis = basis\n",
-    "M = np.ones((I_n.shape[1], I_n.shape[2]), dtype=bool)\n",
-    "W = make_whitefield_st(I_n, M)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 178,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, ax = plt.subplots(figsize=(10, 5))\n",
-    "ax.imshow(I_n[:, 0])\n",
-    "ax.set_title('Ptychograph', fontsize=20)\n",
-    "ax.tick_params(axis='both', which='major', labelsize=15)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/ptycho.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 95,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "K = I_n.shape[-1] / (dij_pix[0, 1] - dij_pix[1, 1])\n",
-    "N = I_n.shape[0]\n",
-    "dI0_avg = np.mean(np.gradient(I0_gk[0])**2)\n",
-    "p_var = np.mean(I_n)\n",
-    "u_var = (p_var / N + p_var / N / K) / dI0_avg / np.mean(I_n**2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 179,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x360 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(10, 5))\n",
-    "axes[0].plot(I_n[1, 0] / W[0] )\n",
-    "axes[1].plot(I_n[-1, 0] / W[0])\n",
-    "ax.tick_params(axis='both', which='major', labelsize=15)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/ptycho.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 180,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 2733.58it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "#---------------------------\n",
-    "# Intialise\n",
-    "#---------------------------\n",
-    "\n",
-    "# generate pixel map\n",
-    "u, dij_pix, res = st.generate_pixel_map(W.shape, dij, basis, x_ps, y_ps, z, df, verbose=False)\n",
-    "di, dj = pixel_translations(basis, dij, df, z)\n",
-    "\n",
-    "# make reference image\n",
-    "I0, n0, m0 = st.make_object_map(I_n, M, W, dij_pix, u, subpixel=True)\n",
-    "\n",
-    "I0_gk, di, dj = make_reference(I_n.astype(np.float64), W.astype(np.float64), u, di, dj, ls=8.)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 181,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, ax = plt.subplots(figsize=(10, 6))\n",
-    "ax.plot(I0[0])\n",
-    "ax.plot(I0_gk[0])\n",
-    "ax.set_title('Reference before', fontsize=20)\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/reference_1595.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 182,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 3889.96it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3081.07it/s]\n",
-      "updating pixel map: 5.42e-01: 100%|██████████| 9/9 [00:00<00:00,  9.38it/s]\n",
-      "updating object map and translations: 5.53e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 3962.69it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 2888.72it/s]\n",
-      "updating pixel map: 4.97e-01: 100%|██████████| 9/9 [00:00<00:00, 22.32it/s]\n",
-      "updating object map and translations: 5.45e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 3721.93it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 2807.00it/s]\n",
-      "updating pixel map: 4.90e-01: 100%|██████████| 9/9 [00:00<00:00, 15.55it/s]\n",
-      "updating object map and translations: 5.41e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 4124.78it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 2924.35it/s]\n",
-      "updating pixel map: 4.86e-01: 100%|██████████| 9/9 [00:00<00:00, 15.08it/s]\n",
-      "updating object map and translations: 5.39e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 4006.82it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 2827.68it/s]\n",
-      "updating pixel map: 4.85e-01: 100%|██████████| 9/9 [00:00<00:00, 15.33it/s]\n",
-      "updating object map and translations: 5.38e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "st_res = st_update(I_n, W, dij, basis, x_ps, y_ps, z, df, u_max=400)\n",
-    "ph_res = phase_fit(st_res['u'], (2, I_n.shape[-1] - 2), x_ps, z, df, wl, u_var)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 183,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(st_res['I0'][0])\n",
-    "axes[0].set_title('Reference image', fontsize=20)\n",
-    "axes[1].plot(ph_res['pix'], ph_res['u_pix'])\n",
-    "axes[1].plot(ph_res['pix'], ab_model(ph_res['pix'], ph_res['fit'].x), color='red')\n",
-    "axes[1].set_title('Pixel map', fontsize=20)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/st_results_andrew_1727.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 184,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(ph_res['theta'], ph_res['angles'])\n",
-    "axes[0].plot(ph_res['theta'], ab_model(ph_res['theta'], ph_res['ang_fit']),\n",
-    "             label='2nd order coeff = {:.3f} rad/rad^2'.format(ph_res['ang_fit'][2]))\n",
-    "axes[0].set_title('Deflection angles', fontsize=20)\n",
-    "axes[1].plot(ph_res['theta'], ph_res['phase'])\n",
-    "axes[1].plot(ph_res['theta'], ph_model(ph_res['theta'], ph_res['ph_fit']),\n",
-    "             label='3rd order coeff = {:.3f} rad/mrad^3'.format(ph_res['ph_fit'][3] * 1e-9))\n",
-    "axes[1].set_title('Phase', fontsize=20)\n",
-    "for ax in axes:\n",
-    "    ax.tick_params(axis='both', which='major', labelsize=12)\n",
-    "    ax.legend(fontsize=12)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/st_fits_andrew_1727.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 185,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "str_res = str_update(I_n, W, dij, basis, x_ps, y_ps, z, df, u_max=200, l_scale=2.5)\n",
-    "phr_res = phase_fit(str_res['u'], (2, I_n.shape[-1] - 2), x_ps, z, df, wl, u_var)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 186,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(str_res['I0'][0])\n",
-    "axes[0].set_title('Reference image', fontsize=20)\n",
-    "axes[1].plot(phr_res['pix'], phr_res['u_pix'])\n",
-    "axes[1].plot(phr_res['pix'], ab_model(phr_res['pix'], phr_res['fit'].x), color='red')\n",
-    "axes[1].set_title('Pixel map', fontsize=20)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/st_results_robust_1727.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 187,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "axes[0].plot(phr_res['theta'], phr_res['angles'])\n",
-    "axes[0].plot(phr_res['theta'], ab_model(phr_res['theta'], phr_res['ang_fit']),\n",
-    "             label='2nd order coeff = {:.3f} rad/rad^2'.format(phr_res['ang_fit'][2]))\n",
-    "axes[0].set_title('Deflection angles', fontsize=20)\n",
-    "axes[1].plot(2 * phr_res['theta'], phr_res['phase'])\n",
-    "axes[1].plot(2 * phr_res['theta'], ph_model(phr_res['theta'], phr_res['ph_fit']),\n",
-    "             label='3rd order coeff = {:.5f} rad/mrad^3'.format(phr_res['ph_fit'][3] * 1e-9))\n",
-    "axes[1].set_title('Phase', fontsize=20)\n",
-    "for ax in axes:\n",
-    "    ax.tick_params(axis='both', which='major', labelsize=12)\n",
-    "    ax.legend(fontsize=12)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/st_fits_robust_1727.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 84,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df_arr = np.linspace(1e-5, 1e-4, 20)\n",
-    "dI0_arr = []\n",
-    "for df in df_arr:\n",
-    "    u, dij_pix, res = st.generate_pixel_map(W.shape, dij, basis, x_ps, y_ps, z, df, verbose=False)\n",
-    "    di = np.ascontiguousarray(dij_pix[:, 0])\n",
-    "    dj = np.ascontiguousarray(dij_pix[:, 1])\n",
-    "    I0_gk, di, dj = make_reference(I_n.astype(np.float), W.astype(np.float), u, di, dj, 100)\n",
-    "    dI0_arr.append(np.mean(np.gradient(I0_gk[0])**2))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 85,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "7.157894736842105e-05"
-      ]
-     },
-     "execution_count": 85,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df_arr[np.argmax(dI0_arr)]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 87,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAGoCAYAAABbtxOxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAABFKUlEQVR4nO3dd3xdZeHH8c+TNG26Z7r3Blra0nSxEZEhWkH23rJRRBQX+vPnz40iQ2SvFiwbkSEIsoTu3UIp3XvvpM14fn/kgrG2TdomObnJ5/163Vdyzz333m/pae6XJ895TogxIkmSJKlERtIBJEmSpOrEgixJkiSVYkGWJEmSSrEgS5IkSaVYkCVJkqRSLMiSJElSKRbkUkIID4YQVoUQZlTAax0TQphS6pYfQvhaBcSUJElSJQqug/xvIYQjgS3AozHGfhX4ui2AuUDHGOO2inpdSZIkVTxHkEuJMb4DrCu9LYTQI4TwaghhYgjh3RBC33146dOAVyzHkiRJ1Z8FuWz3AtfFGAcDNwF378NrnAU8UaGpJEmSVCnqJB2gOgshNAIOBZ4KIXy2uV7qsVOB/9nF05bGGI8v9RrtgP7Aa5WbVpIkSRXBgrxnGcCGGOPAnR+IMT4LPFuO1zgDeC7GWFDB2SRJklQJnGKxBzHGTcD8EMLpAKHEgL18mbNxeoUkSVLasCCXEkJ4AvgA6BNCWBJCuBQ4F7g0hDAVmAmM3IvX6wp0At6uhLiSJEmqBC7zJkmSJJXiCLIkSZJUiifppbRq1Sp27do16RiSJEmqIhMnTlwTY8zZebsFOaVr165MmDAh6RiSJEmqIiGEhbva7hQLSZIkqRQLsiRJklSKBVmSJEkqxYIsSZIklWJBliRJkkqxIEuSJEmlWJAlSZKkUizIkiRJUikWZEmSJKkUC7IkSZJUigVZkiRJKsWCLEmSJJViQZYkSZJKsSBLkpQGYozEGJOOIdUKdZIOIEmS/m3L9kLmr97Kp6u3MG/1Fj5ds5VPV21hwdqtFBdD0wZZNK2fRbP6WTRrkEWT+lk0q1+XZg1K7jetn3q8QV2apb5vUj+LzIyQ9B9NShsWZEmSqlhxcWTphjzmrdlaUoJXb2FeqhSv3LT98/0yAnRq0YDurRpyWM9WZGVmsDFvBxu2FbBhWwHLNuQze/lmNmzbwdYdRXt8zybZdWjWoG6qPGf959f6dWnaIOvzQt2sQd3PH8vOyqzs/xxStWNBliSpkmzZXsi8VPktKcIlJXjB2q3kFxR/vl/j7Dr0yGnEYT1b0SOnET1yGtI9pxFdWjagXp3yFdQdhcVsyi8pzhvzdrAxr+DzIr0hr4BNeQVs2LaDDXkFbMwrYOn6vM+/Lyre/dSNenUyaNmwLgd3bEZu1+YM6dqCA9s3ISvTWZqquSzIkiTth9KjwZ+u2sK8NXseDe6R04jDe7aie6ki3KpRXULYvykQdetk0KpRPVo1qrdXz4sxsmV7YapYF/z7a2qkelNeASs25TNp0XpenbkCgPpZmQzs1IwhXZuT27UFgzo3o3F21n7ll6oTC7IkSeW0Zst23vtkzX+MBs9fs5Xthf8eDW6SXYfuOY04vGcO3XMa0iOnIT1yGtF5L0aDq1IIgcbZWTTOzqJTGfuu2JjPhIXrmLBgPRMWruPOt+ZSHEvK/wHtmjCkawsGdykZZW7bNLtK8kuVIXhGbInc3Nw4YcKEpGNIkqqZGCNj569j1NhFvDpjOQVFkYwAnVs0oHtOI7q3akiP1v/+2rLh/o8Gp4st2wuZvGg94xesZ8KCdUxetIG8gpK50B2b12dI1xafT8vomdOIDE8UVDUTQpgYY8zdebsjyJIk7cLGvAKenbSEUWMXMXfVFppk1+H84V059ZAO9GrTqFqOBle1RvXqcESvHI7olQNAQVExs5dv+rwwv/vJGp6bvBSApvWzGNyl+eeFuX+Hpp4AqGrLEeQUR5AlSQBTF29g1NiFvDh1GfkFxQzo1IzzhnXm5IPbU7+uhW5vxBhZuHYb4xf8e1rGp6u3AlA3M4ODOzYlt2sLcrs0Z3CX5jRvWDfhxKptdjeCbEFOsSBLUu21bUchL05Zxqixi5i+dCMN6mYycmAHzh3WmX4dmiYdr0ZZu2U7ExeuZ8LC9YxfsI4ZSzdSUFTSRXq1bkRu1xYMSY0yd2xev9ZMV1EyLMhlsCBLUu0zZ+VmRn24kGcnLWXz9kL6tGnMecM7M3JQB5q4KkOVyC8oYuriDZ8X5okL1rN5eyEAbZrU47AerfjKwPYcnloHWqpINWYOcgghG3gHqEdJ/qdjjLfutM/RwAvA/NSmZ2OM/1OFMSVJ1dT2wiJenbGCUR8uYtyCddTNzOCk/m05b3gXBndp7ohlFcvOymRY95YM694SgKLiyJyVm5mwYB3jF6znjdkreXbyUlo2rMuXD27HyIHtOaSzf0+qXGk3ghxK/kU0jDFuCSFkAe8BN8QYPyy1z9HATTHGk8v7uo4gS1LNtmjtNkaNW8hTE5awbusOurRswDlDO3N6bidaOPe12tpeWMTbH6/mhSnLeGP2SrYXFtOxeX1GDmzP1wZ2oFebxklHVBqrMSPIsaTRb0ndzUrd0qvlS5KqRGFRMf/4aBWjxi7inTmrycwIfPGA1pw3vAuH9WjlsmNpoF6dTL50UFu+dFBbNucX8NrMlbwwZSl/+uen3PXWpxzQrglfG9ierwxoT/tm9ZOOqxoi7UaQAUIImcBEoCdwV4zxuzs9fjTwDLAEWEbJaPLMXbzOFcAVAJ07dx68cOHCyg0uSaoSKzbm8+T4RTw5bjErNuXTtkk2Zw3txFlDOnsBixpi9ebtvDRtGS9MWcaUxRsIAYZ2bcHIgR04qX9bmjXwtwIqW408SS+E0Ax4Drguxjij1PYmQHFqGsZJwO0xxl57ei2nWEhSeisujrz/6Roe/3Ahb8xeRVFx5MjeOZw7rDPH9m1NHU/wqrEWrNnKi1OX8fyUpcxbvZWszMBRvVvztUHtObZvG5fn027VyIIMEEK4FdgaY/ztHvZZAOTGGNfsbh8LsiSlp3Vbd/D0xMWMHruIBWu30aJhXU7P7cg5QzvTpWXDpOOpCsUYmblsEy9MWcqLU5exctN2GtbN5Ph+bRk5sAOH9Wjp/yjpP9SYOcghhBygIMa4IYRQH/gi8Kud9mkLrIwxxhDCUCADWFv1aSVJlSHGyMSF63n8w4W8PH0FO4qKGdK1Od86rjcn9GvrVe5qqRAC/To0pV+HpnzvxAMYO38tL0xexsszlvPspKW0alSXkw9uz1cHtmdQp2auhKHdSrsR5BDCwcAjQCYlxXdMjPF/QghXAsQY7wkhXAtcBRQCecCNMcZ/7el1HUGWpPQwZfEGvv/sdGYt30TjenU49ZAOnDOsC33aupqBdm17YRFvfbSaF6cu5Y3Zq9hRWEznFg0YObA9Iwd2oGfrRklHVEJq7BSLimJBlqTqraComDvenMtdb82lTeN6XHdsL746oD0N66XdL0OVoE35Bbw2YwUvTl3G+3PXUByhX4cmjBzQga8MaO9JnLWMBbkMFmRJqr7mrtrCjWOmMG3JRk4d1IFbv3oQTet7pTvtn1Wb8nlp2nJemLKUqUs2EgIM79aSkQPbc2K/djRt4DFW01mQy2BBlqTqp7g48sgHC/jlKx/RoG4m/3dKf07s3y7pWKqB5q/ZygtTlvLClGXMX7OVupkZnNCvLRce2sUr99VgFuQyWJAlqXpZtiGP7zw9lffnruWYPjn86rSDad3YX3+rcsUYmbF0E89MWsIzk5awOb+Qg9o34YIRXfjqgA4uGVfDWJDLYEGWpOohxsjzU5by4xdmUlQc+dHJB3LWkE6O4KnKbd1eyPNTlvLYBwv5aMVmmtbP4swhnThvWBc6t2yQdDxVAAtyGSzIkpS89Vt38IPnp/Py9BUM7tKc284Y4FrGSlyMkXHz1/HoBwt5deYKimPkmD6tOX9EF47qleMly9OYBbkMFmRJStZbH6/i5qensWHbDr51XG++cWQPMi0eqmZWbMxn9LhFjB67iDVbttO1ZQPOG96F0wd38qS+NGRBLoMFWZKSsXV7IT9/eTajxy6iT5vG3HbmAA5q3zTpWNIe7Sgs5tWZK3j0XwuYsHA99bMy+dqg9pw/vCsHtm+SdDyVkwW5DBZkSap6Exeu48YxU1m0bhuXH9GdG4/rTXaWJ0EpvcxctpHHPljI81OWkl9QzNCuLTh/RBdO6NeWLC9tXa1ZkMtgQZakqrOjsJg/vDGHe97+lHZN63PbGQMY1r1l0rGk/bJxWwFPTVzMox8sZNG6bbRuXI+zh3bmnGGdadPEFViqIwtyGSzIklQ1Pl6xmW/9ZQqzlm/ijNyO/OjkA2mc7dxN1RzFxZG356zmkQ8W8M+PV1MnI3BCv7ZcMKIrQ7q6pnJ1sruC7PU5JUlVorg48sB78/nNax/TOLsO954/mC8d1DbpWFKFy8gIHNO3Ncf0bc2CNVt5/MOFjJmwmJemLadv28ZcMKIrXxvUngZ1rWHVlSPIKY4gS1LlWbxuGzc9NZWx89dx3IFt+MWp/WnVqF7SsaQqk7ejiBemLOWRDxYye/kmGmfX4YzcTpw/vAtdW7mUYVKcYlEGC7IkVbwYI09PXMJP/zoLgFu/ciCnDe7or5hVa8UYmbhwPY98sJBXpi+nsDhyVO8cLjy0C0f1bu3ShlXMglwGC7IkVaw1W7bz/Wen8/dZKxnarQW/O30AnVp49THpM6s25fPEuMWMGruQVZu307lFA84b3pkzcjvRrEHdpOPVChbkMliQJanivD5rJbc8O41NeYV85/g+XHp4N682Ju1GQVExr81cwaMfLGTc/HVkZ2Vw+uBOXHp4N6dfVDILchksyJK0/zbnF/Czl2YxZsISDmjXhD+cOZA+bRsnHUtKG7OXb+Kh9+fz/ORlFBQX86UD23DFkd0Z3KVF0tFqJAtyGSzIkrR/xs1fx41jprBsQx5XHtWDb36xN3XreJEEaV+s2pzPo/9ayGMfLmRjXgGHdG7GFUd257gD2zpPuQJZkMtgQZakfbO9sIjb/j6He9+dR6fmDfj9mQMc7ZIqyLYdhTw1YQkPvDefReu20aVlAy49vBunDe7oMnEVwIJcBguyJO29Wcs2ceOYKXy0YjPnDOvMD046gIb1/NCWKlpRceTvM1fw53fmMWXxBpo1yOL84V24YERXchq7ZOK+siCXwYIsSXvn4ffn8/OXZ9OsQV1+/fWDOaZv66QjSTXeZ8vE3fvOPF6fvZKsjAxOGdSBy47oRq82zvffW15JT5JUIWKM/OGNT7j9H5/wxQPa8OvTDqZFQ5ekkqpCCIHcri3I7dqC+Wu28sB783hqwhL+MmExX+jbmsuP6M7w7i1ca3w/OYKc4giyJJUtxsjP/zab+9+bz+mDO/LLrx/sCUNSwtZu2c7jHy7i0Q8WsHbrDvp1aMLlR3TnpP7tyMr0RNk9cYpFGSzIkrRnxcWRH74wg9FjF3HhiC7c+pWDXNtYqkbyC4p4bvJS7nt3HvNWb6VDs/pcfFhXzhramUaeG7BLFuQyWJAlafcKi4r5ztPTeG7yUq46ugc3H9/HX+FK1VRxceTNj1Zx77vzGDd/HY2z63DO0M5cdFhX2jWtn3S8asWCXAYLsiTt2vbCIm54YgqvzlzBd47vwzXH9Ew6kqRymrp4A/e9O4+Xpy8nIwS+OqA9lx3RnQPbN0k6WrVgQS6DBVmS/lvejiKufHwib89ZzY9PPpBLDu+WdCRJ+2Dxum08+P58/jJ+Mdt2FHFEr1ZcdkR3juzVqlb/NsiCXAYLsiT9py3bC7n04fGMW7COX5zSn7OGdk46kqT9tHFbAaPHLeKh9+ezavN2+rZtzGVHdOerA9rXyitfWpDLYEGWpH/buK2ACx8ax/SlG7ntjAGMHNgh6UiSKtCOwmJenLqM+96Zx8crN9OmST0uPLQr5w7tQtMGWUnHqzIW5DJYkCWpxJot2zn/gXF8umoLd54ziC8d1DbpSJIqSYyRdz5Zw/3vzuPdT9bQoG4mZw7pxCWHdaNTiwZJx6t0FuQyWJAlCZZvzOPc+8eybEMe912QyxG9cpKOJKmKzFq2ifvfnceLU5dRHCMn9W/H5Ud0Z0CnZklHqzQW5DJYkCXVdovWbuOc+z9kw7YCHrxoCEO7tUg6kqQELN+Yx8P/WsDoDxexeXshQ7u14IojuvOFvq1r3NrnFuQyWJAl1WZzV23hvPvHkl9YxCMXD63RI0aSymdzfgF/Gb+Yh95fwNINeXTPacjlR3TnlEEdyM7KTDpehbAgl8GCLKm2mrlsIxc8MI4QAo9fNpS+bV0fVdK/FRYV8/KMFdz7zqfMWLqJlg3rcsGIrpw/ogstGtZNOt5+sSCXwYIsqTaatGg9Fz04jkb16vD4ZcPontMo6UiSqqkYIx/OW8d9787jzY9WkZ2VwWmDO3Lp4d3p1qph0vH2ye4KshfmlqRa6oNP13LZI+Np1bgeoy4bRsfmNf+MdUn7LoTAiB4tGdGjJXNXbeb+d+czZvwSRo1dxHEHtOGKI7szuEvzGnHhEUeQUxxBllSbvPXxKq58bCKdWzTg8cuG0aZJdtKRJKWhVZvzeeyDhTz24UI2bCtgUOdmXH5Ed44/qC2ZaXBCn1MsymBBllRbvDJ9Odc/OZnebRrz2KXD0n4OoaTkbdtRyDMTl3D/e/NZuHYbnVs04NLDu3F6bkca1K2+ExYsyGWwIEuqDZ6dtISbnprKoM7NefCiITStX3uumCWp8hUVR16ftZL73p3HxIXraVo/i/OGd+bCEV1pXQ1/U2VBLoMFWVJNN2rsQn74/AxGdG/JfRfk0rBe9R3VkZT+Ji5cx33vzOe1WSvIysjga4Pac9kR3endpnHS0T5XY07SCyFkA+8A9SjJ/3SM8dad9gnA7cBJwDbgohjjpKrOKknVxX3vzOPnL8/mC31bc/e5h9SYNUwlVV+Du7Rg8PktWLBmKw++P58xExYzZsISju6TwxVHdGdEj5bV9oS+tBtBTpXfhjHGLSGELOA94IYY44el9jkJuI6SgjwMuD3GOGxPr+sIsqSaKMbI7f/4hD+88Qlf7t+O3585kLp1MpKOJakWWr91B49/uJBHPljImi3bOah9E644sjsn9W9HVmYyP5d2N4Kcdj8lY4ktqbtZqdvOLX8k8Ghq3w+BZiGEdlWZU5KSFmPkF698xB/e+ITTBnfkj2cPshxLSkzzhnW57thevPfdY/jV1/uzvbCYG56cwlG/fov73pnH5vyCpCN+Li1/UoYQMkMIU4BVwOsxxrE77dIBWFzq/pLUNkmqFYqLIz98fgb3vjOPC0Z04ddfPzgtllySVPNlZ2Vy5pDO/P2bR/LgRbl0admQn788m/EL1iUd7XNpNwcZIMZYBAwMITQDngsh9Isxzii1y64+Bf5rLkkI4QrgCoDOnTtXRlRJqnKFRcXc/PQ0np28lCuP6sF3T+hTbef5Saq9MjICX+jbhi/0bcOsZZvo27b6nLyXliPIn4kxbgD+CZyw00NLgE6l7ncElu3i+ffGGHNjjLk5OTmVFVOSqsyOwmKue2Iyz05eyk1f6m05lpQWDmzfhIxq9FuutCvIIYSc1MgxIYT6wBeBj3ba7UXgglBiOLAxxri8apNKUtXKLyjiiscm8MqMFfzo5AO59gu9LMeStA/ScYpFO+CREEImJQV/TIzxpRDClQAxxnuAlylZwWIuJcu8XZxUWEmqClu2F3LZI+MZO38dvzi1P2cPddqYJO2rtCvIMcZpwKBdbL+n1PcRuKYqc0lSUjZuK+DCh8YxfelG/nDmQEYO9JxkSdofaVeQJUn/tn7rDs69fyxzV23h7nMP4fiD2iYdSZLSngVZktLU9sKSOcdzV2/hvgtzOaq3JxtLUkVIu5P0JEklFwH53jPTGb9gPb87fYDlWJIqkAVZktLQHW/O5bnUUm5fGdA+6TiSVKNYkCUpzbwwZSm3vT6HUw/pwDXH9Ew6jiTVOBZkSUojExeu4ztPT2Notxb84tT+rnMsSZXAgixJaWLR2m1c/uhE2jfN5s/nDaZencykI0lSjWRBlqQ0sDGvgIsfHkdRceTBi4bQvGHdpCNJUo1lQZakaq6gqJirR01k0bpt/Pn8wXTPaZR0JEmq0VwHWZKqsRgjP3p+Bu/PXctvTjuY4d1bJh1Jkmo8R5AlqRq77915PDl+Mdcc04PTczslHUeSagULsiRVU6/OWMEvXvmIL/dvx7eP65N0HEmqNSzIklQNTV+ykW/+ZTIDOjbjd2cMICPD5dwkqapYkCWpmlm2IY9LHxlPy4b1uO+CXLKzXM5NkqqSBVmSqpEt2wu59JEJ5O0o4sGLhpDTuF7SkSSp1nEVC0mqJoqKI9c/MZk5Kzfz4EVD6NO2cdKRJKlWcgRZkqqJ//3bLN78aBU/+epBHNU7J+k4klRrWZAlqRp49IMFPPT+Ai49vBvnD++SdBxJqtUsyJKUsH9+vIqfvDiTLx7Qmu+fdEDScSSp1rMgS1KCPlqxiWtHT6Zv2ybcftYgMl3OTZISZ0GWpISs2pzPpQ9PoGG9TB64KJeG9TxvWpKqA38aS1IC8nYUcfmjE1m3dQdPXTmCdk3rJx1JkpRiQZakKlZcHLlxzBSmLdnAn88bTL8OTZOOJEkqxSkWklTFfvP3j3llxgp+cNIBfOmgtknHkSTtxIIsSVVozPjF/Omfn3LOsM5ceni3pONIknbBgixJVeRfn67h+89N54herfjpVw8iBFeskKTqyIIsSVXg09VbuPKxiXRr1ZA7zzmErEx//EpSdeVPaEmqZOu27uCSh8eTlZnBgxcNoWn9rKQjSZL2wFUsJKkSbS8s4huPTWD5xnyeuHw4nVo0SDqSJKkMjiBLUiWJMfK9Z6YzfsF6fnf6AAZ3aZ50JElSOViQJamS3PHmXJ6bvJRvH9ebrwxon3QcSVI5WZAlqRK8MGUpt70+h1MHdeDaL/RMOo4kaS9YkCWpgk1cuI7vPD2NoV1b8Iuv93c5N0lKMxZkSapAi9Zu44pHJ9K+aTZ/Pn8w9epkJh1JkrSXLMiSVEE25hVwySPjKSyOPHDREJo3rJt0JEnSPrAgS1IFKCgq5ppRk1iwZiv3nDeYHjmNko4kSdpHroMsSRXg1hdn8t7cNfz6tIMZ0aNl0nEkSfvBEWRJ2k9jJixm9NhFXHlUD87I7ZR0HEnSfrIgS9J+mL18Ez96fgYjurfkO8f3STqOJKkCWJAlaR9t2V7INaMm0aR+FrefPZDMDJdzk6SaIO0KcgihUwjhrRDC7BDCzBDCDbvY5+gQwsYQwpTU7cdJZJVUc8UYueXZ6SxYu5U/njWI1o2zk44kSaog6XiSXiHw7RjjpBBCY2BiCOH1GOOsnfZ7N8Z4cgL5JNUCj3+4kL9OXcZ3ju/jSXmSVMOk3QhyjHF5jHFS6vvNwGygQ7KpJNUm05Zs4GcvzeboPjlcdVSPpONIkipY2hXk0kIIXYFBwNhdPDwihDA1hPBKCOGg3Tz/ihDChBDChNWrV1dmVEk1xMZtBVw9ahKtGtXl92cMJMN5x5JU46RtQQ4hNAKeAb4ZY9y008OTgC4xxgHAHcDzu3qNGOO9McbcGGNuTk5OpeaVlP5ijNz09FRWbMznjnMO8Up5klRDpWVBDiFkUVKOR8UYn9358RjjphjjltT3LwNZIYRWVRxTUg1z/7vzeX3WSm456QAGd2medBxJUiVJu4IcQgjAA8DsGONtu9mnbWo/QghDKflzrq26lJJqmgkL1vHLVz/i+IPacMlhXZOOI0mqROm4isVhwPnA9BDClNS27wOdAWKM9wCnAVeFEAqBPOCsGGNMIKukGmDtlu1cO3oyHZrV59enDSD1/9+SpBoq7QpyjPE9YI+fTjHGO4E7qyaRpJqsuDjyrTFTWbdtB89edShN62clHUmSVMnSboqFJFWlu96ayztzVnPrVw6kX4emSceRJFUBC7Ik7ca/5q7h92/MYeTA9pwztHPScSRJVcSCLEm7sGpTPtc/OYVurRryf6f0d96xJNUiaTcHWZIqW2FRMdc9MZkt2wsYddkwGtbzR6Uk1Sb+1Jeknfz+jTmMnb+O354+gD5tGycdR5JUxZxiIUmlvPXxKu5661POzO3EaYM7Jh1HkpQAC7IkpSzbkMe3/jKFvm0b89ORByUdR5KUEAuyJAE7Cou5ZvQkCosid597CNlZmUlHkiQlxDnIkgT86tWPmLxoA3eeM4juOY2SjiNJSpAjyJJqvVdnrOCB9+Zz4YgunHxw+6TjSJISZkGWVKstXLuV7zw9lQEdm/L9Lx+QdBxJUjVgQZZUa+UXFHH1qEkE4M5zDqFeHecdS5LKMQc5hFAXOK8KsgBMizFOqKL3klTL/eylWcxcton7LsilU4sGSceRJFUT5TlJrzFwf2UHASLwO8CCLKnSvTBlKaPGLuIbR3bnuAPbJB1HklSNlHcVi2eAmyozCNADOKGS30OSmLtqC7c8O50hXZtz0/F9ko4jSapmyluQt8QYF1ZmkBBCdmW+viQBbNtRyNWjJpKdlckdZx9CVqanYkiS/lN5CnIe8PfKDgKsA96tgveRVEvFGPnh8zP4ZNUWHrl4KG2b+v/lkqT/VmZBjjFuA56o7CAxxtXAXyv7fSTVXk9NWMKzk5Zy/bG9OLJ3TtJxJEnVlL9blFQrzF6+iR+9MIPDerbkhmN7JR1HklSN7VVBDiE0CyF8OYRwaAgh7PRYwxDCjys2niTtv835BVw9ahJN62fxhzMHkZkRyn6SJKnWKndBDiEcBMwGXgDeA8aHELqU2qURcGvFxpOk/RNj5HvPTGfh2q3ccfYgchrXSzqSJKma25sR5F8AHwBNgQ7APOD9EIK/q5RUbT324UL+Nn05Nx3fh2HdWyYdR5KUBsq7zBvAcOCYGONWYCtwRgjhNuCfIYRjgI2VEVCS9tXUxRv42UuzOKZPDlce2SPpOJKkNLE3BbkeJVe7+1yM8cbUXOS3gbMrMpgk7Y+N2wq4ZvQkWjfO5rYzBpLhvGNJUjntTUH+GMgFZpXeGGP8Vgghg5K5yZKUuBgj335qCis35TPmGyNo3rBu0pEkSWlkb+YgP8duRoljjDcAjwMO0UhK3H3vzuON2au45cQDGNS5edJxJElpptwFOcb4ixjjiXt4/JoYo+sqS0rUhAXr+NWrH3Niv7ZcfFjXpONIktKQhVZSjbF2y3auHT2Zjs3r86vTDman5dolSSqXvZmDLEnVVnFx5MYxU1m3bQfPXnUoTbKzko4kSUpTFV6QQwgNgIZAFiXLwW2OMRZX9PtIUmkPvDeft+es5mcjD6Jfh6ZJx5EkpbH9KsghhEbAycBRwBCgB9Bkp92KQggLKVn94h3g1RjjzP15X0kqbdqSDfz6tY84/qA2nDe8S9lPkCRpD/apIIcQ+gM3A6cC9YF8Sq6sNxlYB2wHCoFsSkaTW1OyRNxXgF+HEKYDfwQeizEW7OefQVIttjm/gOuemExOo3r86uvOO5Yk7b+9KsghhDbA74ATgb8CV1By+en5Mca4p+emnt8IGAwcAVwN/DCE8K0Yo2soS9onP35hJovXbePJK0bQrIHrHUuS9l+5V7EIIZwIPAv8HWgXY7woxjgqxjivPOUYIMa4Jcb4dozxf2OMn40ofzWE8FBq7rIkldszE5fw3OSl3HBsb4Z2a5F0HElSDVGuEeQQwiVAS+CoGGNhRb15ai7ypSGEg4HbQwg3xxjXV9TrS6q55q3ewo9emMHQbi249gs9k44jSapByjvF4qUY46rKChFjnBZCuJqS+cqStEfbC4u47onJ1K2Twe1nDSQzw3nHkqSKU66CXJnluNR7FAAbKvt9JKW/X73yMTOXbeLe8wfTrmn9pONIkmqYSr+SXgihqLLfQ1Lt8eZHK3nw/flcOKILXzqobdJxJEk1UFVcatrffUqqECs35XPTU9M4oF0TbjnpgKTjSJJqqKooyOVa4aK8QgidQghvhRBmhxBmhhBu2MU+IYTwxxDC3BDCtBDCIRWZQVLVKyqOfPPJKeTtKOKOsweRnZWZdCRJUg21rxcKaUPJFfQ6UFKAlwF/izGuKON5OTHG1fvynqUUAt+OMU4KITQGJoYQXo8xziq1z4lAr9RtGPCn1FdJaeqetz/lg3lr+fXXD6Zn60ZJx5Ek1WB7PYIcQrgKeBPoCqwCVgPdgH+kVqLYk3+FELrv7XuWFmNcHmOclPp+MzCbkqJe2kjg0VjiQ6BZCKHd/ryvpORMXLiO216fw1cGtOf03I5Jx5Ek1XD7MoL8TWBgjDGv9MYQws+BqcDde3juy5SU5JM+K7mp5x4J/CLGeNjeBAkhdAUGAWN3eqgDsLjU/SWpbct3ev4VlFwNkM6dO+/NW0uqIhvzCrj+iSm0b5bNz0/p56WkJUmVbl/mIEeg+S62t6CM+cYxxhuA3wJvhRC+FEIYGEJ4FXgLWLQ3IVKXrX4G+GaMcdPOD+8m98557o0x5sYYc3Nycvbm7SVVgRgjtzw7jZWb8vnjWYNokp2VdCRJUi2wLyPINwL/DCHM5N+jtJ2BA4FvlfXkGONvQwiZwEuUFNnngYNTV9UrlxBCFiXleFSM8dld7LIE6FTqfkdK5klLSiNPjFvMy9NX8N0T+jKo867+v1ySpIq31wU5xvhyCOE1YCjQnpKSuxQYF2Pc45rHIYROwA+Bi4DxwABKTu7bm3IcgAeA2THG23az24vAtSGEJyk5OW9jjHH5bvaVVA3NWbmZn/51Jkf0asU3jtyvUxckSdorZRbkEMLjwMTUbXKMcXOqCH+wD+/3CTANODnG+HoI4QvAMyGEDjHGn5fzNQ4DzgemhxCmpLZ9n5JRbGKM91Ay1/kkYC6wDbh4H7JKSkh+QRHXjp5E4+w6/O6MAWR4KWlJUhUqzwhye0rKZjOgOIQwF5jEv0vzpF3MAd6d82KMT392J8b4ZgjhaOBvqZJc1ioYxBjfo4yLj8QYI3BNOTNJqmb+92+zmLNyC49cMpTWjbOTjiNJqmXKLMgxxi8ApJZnywUOAQYDt5A6MS+E8GmMsXc5XuvpXWybGkI4DHhlL7NLqoFenbGcxz9cxBVHdueo3p48K0mqeuWegxxjnAfMA8Z8ti21zNpnpblMIYTBwClAS2AlJdMtXosxLkyVZEm12NINedz89DQGdGzKTV/qk3QcSVItVe6CvItyOxX4e2pU+L9Ghnfx/MuBuyi5yMha4GygEbA1hPCTGOPv9z6+pJqisKiYG56YTHGEP549iLp19mUVSkmS9l+5PoFS5fYDSkaLm1BysZCngGUhhDKXdkv5X0rmIJ9ASbl+kpIpGlcBt4QQbti76JJqkj/+4xMmLFzPz0/pR5eWDZOOI0mqxco7RPMz9qPchhDqAjnAc6lNVwDfjjFuijGOBoYA1+5Dfkk1wAefruWOt+Zy2uCOjBy485XjJUmqWmUW5FS5bc1+lNsY4w5gOtAmtWkNcE0I4bMpHpuBzL2PLyndrdu6g2/+ZTLdWjbkp189KOk4kiSVXZArqtzGGAfEGJek7l4FXA5sDiHMoGR95N1d9ENSDRVj5Oanp7J+awF/PHsQDevty8U9JUmqWOX6NIoxDih19ypKVrL4aQjhU6AdcOvevGmMcXIIoQ8lF/1oC0yPMX60N68hKf098q8FvDF7FT8++UD6dWiadBxJkoB9u9T03pbbXV7UI8ZYDLy7t+8vqWaYuWwj//fyRxzbtzUXH9Y16TiSJH1un36fuTflNsboWk2S/sO2HYVc98RkmjfM4jenDyAELyUtSao+nPAnqcrd+sJM5q/ZyqjLhtGiYd2k40iS9B/Kuw7ywZUdJITQIoTQvrLfR1KyXpiylKcmLuHaY3pyaI9WSceRJOm/lHf6Q8cQwu0hhOaVESKE8BVKLiSyujJeX1L1sHDtVn7w3AxyuzTnhmN7JR1HkqRdKldBjjG+DDwIvBpC+EkIod3+vnEo8eUQwhvAYOCaGGPB/r6upOppR2Ex1z8xmYwAfzhrIHUyPT1BklQ9lXsOcoxxagjhKOAHwJwQwmTgdeBfwKwY4/I9PT+EkA30pqQMHwmcBHwKXBdjnLiP+SWlid+9/jFTl2zkT+ceQsfmDZKOI0nSbu3VSXoxxnzgRyGEPwLXAZcCPwViCCEfWAWsB/KBYqAu0JCSK/E1p2TJtyJKivUFMcbXKujPIakae2fOav789jzOGdaZE/vv9y+gJEmqVPu6zNtq4MfAj0MIw4CjKBkZ7gl0oKQU1wHyKCnMU4FZwPvAGzHGtfsfXVI6WL15OzeOmUrvNo348ckHJh1HkqQy7fcybzHGscDYCsgiqYYpLo7cOGYKm/MLGH35MLKzyrwqvSRJifMsGUmV5r535/HuJ2v48VcOpHebxknHkSSpXCzIkirFlMUb+M1rH3Niv7acM7Rz0nEkSSq3MgtyCKFZCOEXlR0khNAthHBzZb+PpMq3Ob+A65+YTJsm2fzy1IO9lLQkKa2UZw5yJtCmsoNQsuKFl9WS0lyMkR88N4OlG/IY843hNG2QlXQkSZL2SnlP0usbQriKkmXaKktVlHBJlewv4xfz4tRlfPu43gzu0iLpOJIk7bXyFuThqVtl+20VvIekSjJj6UZ+/OJMjujViquP6Zl0HEmS9kmZBTnGuLYiLi1dTlur6H0kVbCNeQVcPWoSLRrU5Q9nDiQzw3nHkqT0VK4R5BjjysoOIil9xRj5zlNTWbYhj798YzgtG9VLOpIkSfvMZd4k7bf7353P32et5JaTDnDesSQp7e1zQQ4hfD+E0Lciw0hKP+MXrOOXr37Eif3acslhXZOOI0nSftufEeT/Bc4ovSGEUH//4khKJ2u2bOfa0ZPo1Lw+vzrN9Y4lSTVDRU+xuDmEsGpXD4QQ2oYQGlbw+0lKSFFx5JtPTmHDtgLuPncwTbJd71iSVDNUxhzklrvZ/g1gQyW8n6QE3P6PT3hv7hp+NrIfB7ZvknQcSZIqTFWfpOdJgVIN8Pac1dzx5iecNrgjZwzplHQcSZIqlIVV0l5ZtiGPbz45mT5tGvOzkf2SjiNJUoWzIEsqtx2FxVwzehIFRZG7zz2E+nUzk44kSVKFK++lpncnVkgKSWnhl698xORFG7jrnEPontMo6TiSJFWK/S3IPwwhjATGp26d9z+SpOro5enLefD9+Vx0aFe+fHBVXX1ekqSqtz8F+R/AIOCQ1O2Kzx4IIbwNTC11m74f7yMpYfPXbOXmp6cxsFMzvn/SAUnHkSSpUu1zQY4xHgcQQugO5Ja6DQKOSN0+m4JRDGzZr6SSEpFfUMRVj08kKzNw17mHULeOpy5Ikmq2/Z1iQYxxHjAPGPPZthBCb/6zNA8EmuKcZSnt/PiFGXy8cjMPXTSEDs28WKYkqebb74K8KzHGOcAcYDRAKLn+7AHA4P197RDCg8DJwKoY43+tMRVCOBp4AZif2vRsjPF/9vd9pdpozITFjJmwhOu/0JOj+7ROOo4kSVWiUgryzmKMEZiVuu2vh4E7gUf3sM+7McaTK+C9pFpr1rJN/Oj5GRzWsyU3fLF30nEkSaoyaTeZMMb4DrAu6RxSTbY5v4BrRk+iWYMsbj9rEJkZIelIkiRVmbQryOU0IoQwNYTwSgjhoN3tFEK4IoQwIYQwYfXq1VWZT6q2Yox895lpLFq3jTvPOYRWjeolHUmSpCpVEwvyJKBLjHEAcAfw/O52jDHeG2PMjTHm5uTkVFU+qVp76P0FvDx9Bd89oQ9DurZIOo4kSVWuxhXkGOOmGOOW1PcvA1khhFYJx5LSwsSF6/m/l2dz3IFtuPyI7knHkSQpETWuIIcQ2qZWzSCEMJSSP+PaZFNJ1d+6rTu4dvQk2jXL5renDyD1z0iSpFqnSlaxqEghhCeAo4FWIYQlwK1AFkCM8R7gNOCqEEIhkAeclVpFQ9JuFBdHvvmXKazduoNnrzqUpvWzko4kSVJi0q4gxxjPLuPxOylZBk5SOd351lzembOa/zulP/06NE06jiRJiapxUywk7Z33PlnD79+Yw6mDOnD20E5Jx5EkKXEWZKkWW7ExnxuenEyv1o3431P6Oe9YkiQsyFKtVVBUzLWjJ5FXUMTd5w6mQd20m3ElSVKl8BNRqqV+89rHTFi4nj+ePYierRslHUeSpGrDEWSpFnpt5grufWceF4zowlcHtE86jiRJ1YoFWaplFq7dyk1PTWVAx6b84MsHJB1HkqRqx4Is1SL5BUVc9fgkMkLgznMOoV6dzKQjSZJU7TgHWapFfvrXmcxavokHL8qlU4sGSceRJKlacgRZqiWembiEJ8Yt5uqje/CFvm2SjiNJUrVlQZZqgY9XbOYHz09nePcW3Hhc76TjSJJUrVmQpRpuy/ZCrho1kcbZWfzx7EHUyfSfvSRJe+InpVSDxRj53jPTWLBmK3ecPYjWjbOTjiRJUrVnQZZqsMc+XMhL05Zz0/F9GN69ZdJxJElKCxZkqYaasngDP3tpFsf2bc2VR/ZIOo4kSWnDgizVQMs35nHlYxNp3Tib350xgIyMkHQkSZLShgVZqmE25Rdw8UPj2bq9kPsvzKVZg7pJR5IkKa14oRCpBtlRWMzVj09i7qotPHzxUA5o1yTpSJIkpR0LslRDxBi55dnpvDd3Db89fQCH92qVdCRJktKSUyykGuL3b3zCM5OW8K0v9ua0wR2TjiNJUtqyIEs1wJjxi/njPz7hjNyOXH9sz6TjSJKU1izIUpp7e85qbnluOkf0asXPT+lPCK5YIUnS/rAgS2ls5rKNXP34RHq3aczd5x5ClpeRliRpv/lpKqWppRvyuPih8TSpn8VDFw2hcXZW0pEkSaoRLMhSGtqYV8DFD40jb0cRD188lLZNs5OOJElSjeEyb1Ka2VFYzJWPTWT+mq08cvFQ+rRtnHQkSZJqFAuylEZijHz3mWl8MG8tt50xgEN7utaxJEkVzSkWUhq57fU5PDd5KTd9qTenHuJax5IkVQYLspQmnhy3iDvenMtZQzpxzTGudSxJUmWxIEtp4K2PV/GD52dwVO8cfva1fq51LElSJbIgS9XcjKUbuWbUJPq2bcxdrnUsSVKl85NWqsaWrN/GxQ+Pp3mDujx40RAa1fO8WkmSKpuftlI1tXFbARc/NJ78giJGXTaMNk1c61iSpKrgCLJUDW0vLOIbj09gwdqt/Pn8wfRu41rHkiRVFUeQpWomxsjNT0/jw3nruP2sgRzaw7WOJUmqSo4gS9XMb177mBemLOM7x/dh5MAOSceRJKnWsSBL1ciosQu5+5+fcvbQzlx9dI+k40iSVCtZkKVq4q2PVvGj52dwTJ8cfjbyINc6liQpIRZkqRqYvmQj14yexIHtm3DnOYdQx7WOJUlKjJ/CUsIWr/vPtY4butaxJEmJSruCHEJ4MISwKoQwYzePhxDCH0MIc0MI00IIh1R1Rqm8Nm4r4KKHxrGjsIhHLhlC68audSxJUtLSriADDwMn7OHxE4FeqdsVwJ+qIJO017YXFnH5YxNYvC6P+y7IpWdr1zqWJKk6SLuCHGN8B1i3h11GAo/GEh8CzUII7aomnVQ+xcWRm56axrj56/jN6QczrHvLpCNJkqSUtCvI5dABWFzq/pLUtv8SQrgihDAhhDBh9erVVRJOAvj1ax/z16nL+O4JfV3rWJKkaqYmFuRdrY0Vd7VjjPHeGGNujDE3JyenkmNJJR77cCH3vP0p5w3vzJVHdU86jiRJ2klNLMhLgE6l7ncEliWURfoPb8xaya0vzODYvq35yVdc61iSpOqoJhbkF4ELUqtZDAc2xhiXJx1Kmrp4A9c9MZl+HZpyxzmDXOtYkqRqKu0WXA0hPAEcDbQKISwBbgWyAGKM9wAvAycBc4FtwMXJJJX+bdHabVz6yHhaNqrLAxcOoUHdtPunJ0lSrZF2n9IxxrPLeDwC11RRHKlM67fu4KKHx1FQFHnyiqHkNK6XdCRJkrQHaVeQpXSSX1DEFY9NYMn6PB6/dBg9WzdKOpIkSSqDkyClSrJleyGXPDye8QvWc9sZAxjarUXSkSRJUjk4gixVgvVbd3DRQ+OYsWwTt50xgJMPbp90JEmSVE4WZKmCLd+Yx/kPjGPRum38+bzBfPHANklHkiRJe8GCLFWgeau3cP4D49iYV8CjlwxluJeQliQp7ViQpQoyY+lGLnxwHABPXjGcfh2aJpxIkiTtCwuyVAHGzV/HpQ+Pp3F2HR67bBg9clytQpKkdGVBlvbTmx+t5KrHJ9GxeX0eu3QY7ZvVTzqSJEnaDxZkaT88P3kp335qKge1b8JDFw2hZSMvAiJJUrqzIEv76OH35/OTv85iRPeW3HdhLo3q+c9JkqSawE90aS/FGLn9H5/whzc+4bgD23DH2YPIzspMOpYkSaogFmRpLxQXR/7npVk8/K8FnDa4I788tT91Mr0gpSRJNYkFWSqngqJibn56Gs9NXsqlh3fjBycdQEZGSDqWJEmqYBZkqRzyC4q4dvQk3pi9ipu+1JtrjulJCJZjSZJqIguyVIZN+QVc9sgExi9Yx8++1o/zh3dJOpIkSapEFmRpD9Zs2c6FD47j4xWb+cOZAxk5sEPSkSRJUiWzIEu7sWT9Ni54YBzLNuZx34W5HNOnddKRJElSFbAgS7swd9Vmzn9gHFu2F/L4pcPI7doi6UiSJKmKWJClnUxdvIGLHhpHZkYGf7liBAe2b5J0JEmSVIUsyFIp/5q7hssfnUDzhnV5/NJhdG3VMOlIkiSpilmQpZTXZq7gutGT6dqqAY9eMoy2TbOTjiRJkhJgQZaAMRMW871npnFwx2Y8fPEQmjWom3QkSZKUEAuyar37353H//5tNkf0asU95w2mYT3/WUiSVJvZBFRrxRj57d8/5q63PuWk/m35/ZkDqVcnM+lYkiQpYRZk1UpFxZEfvTCD0WMXcdaQTvz8lP5kZnjpaEmSZEFWLbSjsJgbx0zhpWnLufKoHnz3hD6EYDmWJEklLMiqVbbtKOSqxyfx9pzVfO/Evlx5VI+kI0mSpGrGgqxaY+O2Ai55ZDyTF63nl6f256yhnZOOJEmSqiELsmqFVZvyueDBccxbvZW7zjmEE/u3SzqSJEmqpizIqvGmLN7AtaMnsW7rDh68aAiH92qVdCRJklSNWZBVYxUXR+59dx6/fe1j2jTJZvTlwxnYqVnSsSRJUjVnQVaNtGpTPt9+airvfrKGE/u15ZenHkzTBllJx5IkSWnAgqwa562PV3HTmKls3VHIL07tz1lDOrmMmyRJKjcLsmqM7YVF/PrVj3ngvfn0bduYJ88eTq82jZOOJUmS0owFWTXCvNVbuP7JycxYuokLR3ThlpMOIDvLy0ZLkqS9Z0FWWosx8vTEJdz64kzq1sng3vMH86WD2iYdS5IkpTELstLW5vwCfvDcDF6cuoxh3Vrwh7MG0q5p/aRjSZKkNGdBVlqavGg91z85mWUb8vn2cb25+pieZGZ4Ip4kSdp/FmSlleLiyJ/fmcfv/l6ytvGYbwxncJcWSceSJEk1SEbSAfZWCOGEEMLHIYS5IYTv7eLxo0MIG0MIU1K3HyeRUxXvs8tF/+rVjzj+oLa8fMMRlmNJklTh0moEOYSQCdwFHAcsAcaHEF6MMc7aadd3Y4wnV3lAVZq3PlrFt5+ayrYdhfzy1P6c6drGkiSpkqRVQQaGAnNjjPMAQghPAiOBnQuyaojthUX86pWPefD9krWN7zxnOD1bu7axJEmqPOlWkDsAi0vdXwIM28V+I0IIU4FlwE0xxplVEU4V69PVW7hu9GRmLd/ERYd25Xsn9nVtY0mSVOnSrSDv6nfqcaf7k4AuMcYtIYSTgOeBXrt8sRCuAK4A6Ny5cwXG1P6IMfLUxCXc+sJMsrMyuP+CXL54YJukY0mSpFoi3U7SWwJ0KnW/IyWjxJ+LMW6KMW5Jff8ykBVCaLWrF4sx3htjzI0x5ubk5FRWZu2FTfkFXP/kFG5+ehoDOjXllRuOtBxLkqQqlW4jyOOBXiGEbsBS4CzgnNI7hBDaAitjjDGEMJSS/wlYW+VJtdcmLVrP9U9MZvnGfL5zfB+uPKqHaxtLkqQql1YFOcZYGEK4FngNyAQejDHODCFcmXr8HuA04KoQQiGQB5wVY9x5GoaqkeLiyJ/e/pTbXp9D2ybZjPnGCAZ3aZ50LEmSVEsFu2OJ3NzcOGHChKRj1DorN+Vz45gpvD93LV8+uB3/d0p/mtbPSjqWJEmqBUIIE2OMuTtvT6sRZNUs/5i9ku88PY28HUX86uv9OSPXtY0lSVLyLMiqctsLi/jFyx/x8L8WcEC7Jtxx9iB6tm6UdCxJkiTAgqwqNnfVFq5/omRt44sP68p3T3BtY0mSVL1YkFUl8nYU8fiHC7nt9TlkZ2XwwIW5HHuAy7dJkqTqx4KsSpVfUMSosYu45+1PWb15O0f1zuHXpx1MmybZSUeTJEnaJQuyKkV+QRGjxy7iT6lifGiPltx1ziEM7dYi6WiSJEl7ZEFWhcovKOLJcYu4+5+fsmrzdoZ3b8EdZw9iePeWSUeTJEkqFwuyKkR+QRF/Gb+Yu/85l5WbtjO0WwtuP2sQI3pYjCVJUnqxIGu/bC8sYsz4xdz11qes2JTP0K4t+P2ZAxnRvaVrGkuSpLRkQdY+2V5YxJgJS7j7rbks35hPbpfm/O6MARzaw2IsSZLSmwVZe2VHYTFPTVzMXW/OZdnGfAZ3ac5vThvAYT0txpIkqWawIKtcdhQW8/TEJdz11lyWbsjjkM7N+NVpB3N4z1YWY0mSVKNYkLVHBUXFPDNxCXe8WVKMB3Zqxv+d2p8je1mMJUlSzWRB1i4VFBXz7KSSYrxkfR4DOjXj56f046jeORZjSZJUo1mQ9R8Kiop5bvJS7nxzLovWbePgjk352ch+HN3HYixJkmoHC7IAKPysGL81l4Vrt9G/Q1MevCiXY/q0thhLkqRaxYJcyxUWFfPClGXc8eYnLFi7jX4dmnD/Bbkce4DFWJIk1U4W5ISMGb+YTfkF1K+bSf2sklt26vaf2zLITt3PysyosPcvLCrmxanLuOPNucxfs5WD2jfhvgty+aLFWJIk1XIW5ITc/9485qzcslfPqZMRSkpz3ZLiXLpY16+bSXad1NfU9vp1M/6zeKf225hXwH3vzGPemq0c2K4J954/mOMObGMxliRJwoKcmJeuO4K8giLyU7e8giLydhR9vi1vR/Hn2/P/47Hi/9qWV1DE+q07Pv++9HOLiuMu379v28bcc95gvnRgGzIyLMaSJEmfsSAnpG6dDOrWyaBp/axKfZ+ColShLlWmi4tLCrLFWJIk6b9ZkGu4rMwMsjIzaJJduUVckiSppqi4s74kSZKkGsCCLEmSJJViQZYkSZJKsSBLkiRJpViQJUmSpFIsyJIkSVIpFmRJkiSpFAuyJEmSVIoFWZIkSSrFgixJkiSVYkGWJEmSSrEgS5IkSaVYkCVJkqRSLMiSJElSKSHGmHSGaiGEsBpYmHSOWqgVsCbpEEqUx4A8BuQxIEjmOOgSY8zZeaMFWYkKIUyIMeYmnUPJ8RiQx4A8BgTV6zhwioUkSZJUigVZkiRJKsWCrKTdm3QAJc5jQB4D8hgQVKPjwDnIkiRJUimOIEuSJEmlWJAlSZKkUizIqhIhhE4hhLdCCLNDCDNDCDektrcIIbweQvgk9bV50llVuUIImSGEySGEl1L3PQZqkRBCsxDC0yGEj1I/D0Z4DNQ+IYRvpT4LZoQQngghZHsc1GwhhAdDCKtCCDNKbdvt33kI4ZYQwtwQwschhOOrOq8FWVWlEPh2jPEAYDhwTQjhQOB7wD9ijL2Af6Tuq2a7AZhd6r7HQO1yO/BqjLEvMICSY8FjoBYJIXQArgdyY4z9gEzgLDwOarqHgRN22rbLv/NUPzgLOCj1nLtDCJlVF9WCrCoSY1weY5yU+n4zJR+KHYCRwCOp3R4BvpZIQFWJEEJH4MvA/aU2ewzUEiGEJsCRwAMAMcYdMcYNeAzURnWA+iGEOkADYBkeBzVajPEdYN1Om3f3dz4SeDLGuD3GOB+YCwytipyfsSCryoUQugKDgLFAmxjjcigp0UDrBKOp8v0BuBkoLrXNY6D26A6sBh5KTbO5P4TQEI+BWiXGuBT4LbAIWA5sjDH+HY+D2mh3f+cdgMWl9luS2lZlLMiqUiGERsAzwDdjjJuSzqOqE0I4GVgVY5yYdBYlpg5wCPCnGOMgYCv+Gr3WSc0zHQl0A9oDDUMI5yWbStVM2MW2Kl2X2IKsKhNCyKKkHI+KMT6b2rwyhNAu9Xg7YFVS+VTpDgO+GkJYADwJfCGE8DgeA7XJEmBJjHFs6v7TlBRmj4Ha5YvA/Bjj6hhjAfAscCgeB7XR7v7OlwCdSu3XkZJpOFXGgqwqEUIIlMw7nB1jvK3UQy8CF6a+vxB4oaqzqWrEGG+JMXaMMXal5OSLN2OM5+ExUGvEGFcAi0MIfVKbjgVm4TFQ2ywChocQGqQ+G46l5LwUj4PaZ3d/5y8CZ4UQ6oUQugG9gHFVGcwr6alKhBAOB94FpvPv+affp2Qe8higMyU/NE+PMe48iV81TAjhaOCmGOPJIYSWeAzUGiGEgZScpFkXmAdcTMlgjcdALRJC+ClwJiUrHE0GLgMa4XFQY4UQngCOBloBK4FbgefZzd95COEHwCWUHCPfjDG+UqV5LciSJEnSvznFQpIkSSrFgixJkiSVYkGWJEmSSrEgS5IkSaVYkCVJkqRSLMiSJElSKRZkSZIkqRQLsiRVEyGE90MIcQ+3tyvxvY9OvcdPdvP4gtRlwktv65p6zsMhhB4hhKdDCGtDCJtDCH8PIfRL7ZcTQrg3hLA8hJAfQhgfQjimsv4skrS/6iQdQJL0ueeA13ex/WJKrjT1VtXGKbeulFwVczbwcOr+KcA/QwgjgFeBTcBfgBaUXGr8lRBC7xjjogTyStIeWZAlqZqIMf52520hhN9QUo4fBv6nqjOV01HAD2OMP/9sQwjhR5Tk/exy8lfHGItTj70OPAp8K3WTpGrFKRaSVA2FEncDNwF3AZd8VjCroQXAL3fa9kjqaz3gOztlHw0UAgMrPZkk7QMLsiRVMyGETEpGjK8Cfh1jvDbGGFOPHRlCeDGEsDQ1//eiBKN+ZkqMsWinbctSX+fEGDeXfiC170qgY1WEk6S9ZUGWpGokhJAFPAlcAPwkxvjdnXZpBMwAbgDyqjje7mzceUOMsXB3j6UUAlmVlkiS9oNzkCWpmgghZANPA18Gboox/m7nfWKMLwMvp/Z/uALf/rMpELv7XGjK7suuJNUoFmRJqgZCCA2BF4FjKDmh7U9VHGF96munnR8IIfQEmmFBllRLOMVCkhIWQmgK/J2S1SAuqqhynFqfuLzzlD+iZCm2kSGE1qVeoz7wx4rII0npwhFkSUreaOBQYBzQfTcX6/hFjHH7Xr7uZ4MghXvcC4gxFoQQbgd+BEwOITxHyWfEcZSccLdsT8+XpJrEgixJCQohZABHpu4OTd12tirG+JN9ePn+wGbgb+Xc/1ZgG3A5cAWwgpITBn8CzNqH95ektBRSKwdJktJMCGELcG2M8eFdPNYMWAv8LsZ4cxVHk6S05giyJKWREEIjoGfqbgbQOYQwEFi302WbjwAKgNuqNqEkpT9HkCUpjYQQjgbe2sVDj8QYL6rSMJJUQ1mQJUmSpFJc5k2SJEkqxYIsSZIklWJBliRJkkqxIEuSJEmlWJAlSZKkUizIkiRJUikWZEmSJKkUC7IkSZJUyv8D0Ud591N9vtkAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 720x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, ax = plt.subplots(figsize=(10, 6))\n",
-    "ax.plot(df_arr * 1e6, dI0_arr)\n",
-    "ax.set_ylabel(r'$E\\left[\\left(\\frac{\\partial I_0}{\\partial x}\\right)^2\\right]$', fontsize=20)\n",
-    "ax.set_xlabel(r'$z_1$, um', fontsize=20)\n",
-    "ax.tick_params(labelsize=10)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/defoc_scan_1727.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 64,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "11.800921341125795\n"
-     ]
-    }
-   ],
-   "source": [
-    "K = I_n.shape[-1] / (dij_pix[0, 1] - dij_pix[1, 1])\n",
-    "N = I_n.shape[0]\n",
-    "dI0_avg = np.mean(np.gradient(I0_gk[0])**2)\n",
-    "p_var = np.mean(I_n)\n",
-    "print(np.sqrt((p_var / N + p_var / N / K) / dI0_avg / np.mean(I_n**2)))\n",
-    "# print(np.median((ph_res['u_pix'] - gaussian_filter(ph_res['u_pix'], 20))**2)**0.5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 152,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "i = 0\n",
-    "sw = np.arange(-400, 400)\n",
-    "mu = int(dij_pix[0, 1] - dij_pix[1, 1])\n",
-    "\n",
-    "fs = sw[:, None] + (u[1, 0, i] - dij_pix[:, 1] + m0)[None, :]\n",
-    "\n",
-    "mse = np.sum((I_n[:, 0, i] - I0_gk[0, fs.astype(int)] * W[0, i])**2, axis=-1)\n",
-    "dmse = np.gradient(mse)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 153,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1296x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(18, 6))\n",
-    "axes[0].plot(sw, mse)\n",
-    "axes[0].plot(sw[mu:-mu], np.cumsum((mse[2 * mu:] - mse[:-2 * mu]) / 2 / mu) + mse[mu])\n",
-    "axes[1].plot(sw, np.gradient(mse))\n",
-    "axes[1].plot(sw[mu:-mu], (mse[2 * mu:] - mse[:-2 * mu]) / 2 / mu)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 154,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, ax = plt.subplots(figsize=(10, 6))\n",
-    "ax.plot(sw, np.gradient(np.gradient(mse)))\n",
-    "ax.plot(sw[mu:-mu], (mse[2 * mu:] + mse[:-2 * mu] - 2 * mse[mu:-mu]) / mu**2)\n",
-    "ax.set_ylim(-0.5, 0.5)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def speckle_tracking(cxi_path, df, roi, u_max=100, n_iter=5):\n",
-    "    with h5py.File(os.path.join(exp_dir, fn_dict[key]), 'r') as cxi_file:\n",
-    "        I_n = cxi_file['/entry_1/data_1/data'][:, roi[0]:roi[1], roi[2]:roi[3]]\n",
-    "        basis = cxi_file['/entry_1/instrument_1/detector_1/basis_vectors'][...]\n",
-    "        z = cxi_file['/entry_1/instrument_1/detector_1/distance'][...]\n",
-    "        x_ps = cxi_file['/entry_1/instrument_1/detector_1/x_pixel_size'][...]\n",
-    "        y_ps = cxi_file['/entry_1/instrument_1/detector_1/y_pixel_size'][...]\n",
-    "        wl = cxi_file['/entry_1/instrument_1/source_1/wavelength'][...]\n",
-    "        dij = cxi_file['/entry_1/sample_1/geometry/translation'][...]\n",
-    "\n",
-    "    I_n = I_n[1:-2].astype(np.float32).sum(axis=1)[:, None]\n",
-    "    dij = dij[1:-2]\n",
-    "    basis = basis[1:-2]\n",
-    "    M = np.ones((I_n.shape[1], I_n.shape[2]), dtype=bool)\n",
-    "    W = make_whitefield_st(I_n, M)\n",
-    "    \n",
-    "    res = {'I_var':}\n",
-    "    sigma = np.std(data_st / W)\n",
-    "    \n",
-    "\n",
-    "    # generate pixel map\n",
-    "    u_st, dij_pix, _ = st.generate_pixel_map(w_st.shape, dij, basis_st,\n",
-    "                                             x_ps_st, y_ps_st, z_st, df_st, verbose=False)\n",
-    "\n",
-    "    # make reference image\n",
-    "    O, n0, m0 = st.make_object_map(data_st, mask_st, w_st, dij_pix, u_st, subpixel=True)\n",
-    "    O = gaussian_filter(O, 10)\n",
-    "\n",
-    "    errors = []\n",
-    "    for i in range(max_iter):\n",
-    "\n",
-    "        # calculate errors\n",
-    "        error_total = st.calc_error(data_st, mask_st, w_st, dij_pix, O, u_st,\n",
-    "                                    n0, m0, subpixel=True, verbose=False)[0]\n",
-    "\n",
-    "        # store total error\n",
-    "        errors.append(error_total / data_st.size)\n",
-    "\n",
-    "        # update pixel map\n",
-    "        u_st = st.update_pixel_map(data_st, mask_st, w_st, O, u_st, n0, m0, dij_pix,\n",
-    "                                   search_window=search_window, subpixel=True,\n",
-    "                                   fill_bad_pix=True, integrate=False,\n",
-    "                                   quadratic_refinement=True, verbose=False)[0]\n",
-    "\n",
-    "        # make reference image\n",
-    "        O, n0, m0 = st.make_object_map(data_st, mask_st, w_st, dij_pix, u_st,\n",
-    "                                       subpixel=True, verbose=False)\n",
-    "\n",
-    "        # update translations\n",
-    "        dij_pix = st.update_translations(data_st, mask_st, w_st, O, u_st, n0, m0, dij_pix)[0]\n",
-    "\n",
-    "    # calculate phase\n",
-    "    ur_st = np.array([0, data_st.shape[-1]])\n",
-    "    u_pix = -(u_st[1, 0] - np.arange(u_st.shape[-1]))\n",
-    "    u = u_pix * x_ps_st / z_st\n",
-    "    ph_st = np.cumsum(u) * x_ps_st * df_st / z_st * 2 * np.pi / wl_st\n",
-    "    pix_st = np.arange(roi_st[3] - roi_st[2])[ur_st[0]:ur_st[1]]\n",
-    "    x_st, th_st = pix_st * x_ps_st, pix_st * x_ps_st / z_st\n",
-    "\n",
-    "    # fit model to phase\n",
-    "    fit_data = np.stack((pix_st, gaussian_filter(u_pix, 10)), axis=1)\n",
-    "    pix0 = pix_st[np.argmin(fit_data[:, 1])]\n",
-    "    res_u = least_squares(ab_errors, np.array([0, 0, pix0]), args=(fit_data,), xtol=1e-14, ftol=1e-14,\n",
-    "                          bounds=([-np.inf, -np.inf, pix0 - 400], [np.inf, np.inf, pix0 + 400]),\n",
-    "                          loss='cauchy', f_scale=1)\n",
-    "    fit_u = np.array([res_u.x[0] * z_st / x_ps_st,\n",
-    "                      res_u.x[1] * x_ps_st / z_st,\n",
-    "                      res_u.x[2] * x_ps_st / z_st])\n",
-    "    fit_ph = np.array([fit_u[0] * 2 * np.pi / wl_st * df_st / 3,\n",
-    "                       fit_u[1] * 2 * np.pi / wl_st * df_st,\n",
-    "                       ph_st[np.searchsorted(th_st, fit_u[2])], fit_u[2]])\n",
-    "\n",
-    "    # evaluating errors\n",
-    "    r_sq = 1 - np.sum(ab_errors(res_u.x, fit_data)**2) / np.sum((fit_data[:, 1] - fit_data[:, 1].mean())**2)\n",
-    "    if np.linalg.det(res_u.jac.T.dot(res_u.jac)):\n",
-    "        cov = np.linalg.inv(res_u.jac.T.dot(res_u.jac))\n",
-    "        dalpha = np.sqrt(cov[0, 0]) * z_st / x_ps_st * 2 * np.pi / wl_st * df_st / 3\n",
-    "    else:\n",
-    "        dalpha = 0\n",
-    "\n",
-    "    return {'dev_angle': u, 'phase': ph_st, 'fit': res_u, 'fit_u': fit_u, 'fit_ph': fit_ph, 'pixel_map': u_pix,\n",
-    "            'theta': th_st, 'st_err': np.array(errors), 'r_sq':r_sq, 'dalpha': dalpha, 'ppix': ppix, 'sigma': sigma}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 2924.88it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 4124.23it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3195.10it/s]\n",
-      "updating pixel map: 3.01e-01:   0%|          | 0/7 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Making the whitefield\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "updating pixel map: 2.95e-01: 100%|██████████| 7/7 [00:00<00:00, 12.06it/s]\n",
-      "updating object map and translations: 2.74e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 3720.79it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 2962.49it/s]\n",
-      "updating pixel map: 2.65e-01: 100%|██████████| 7/7 [00:00<00:00, 13.44it/s]\n",
-      "updating object map and translations: 2.63e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 4073.83it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3205.56it/s]\n",
-      "updating pixel map: 2.56e-01: 100%|██████████| 7/7 [00:00<00:00, 13.08it/s]\n",
-      "updating object map and translations: 2.59e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 4117.49it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3108.59it/s]\n",
-      "updating pixel map: 2.52e-01: 100%|██████████| 7/7 [00:00<00:00, 13.27it/s]\n",
-      "updating object map and translations: 2.58e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 3995.49it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3115.86it/s]\n",
-      "updating pixel map: 2.51e-01: 100%|██████████| 7/7 [00:00<00:00, 13.19it/s]\n",
-      "updating object map and translations: 2.57e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 4040.07it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3099.19it/s]\n",
-      "updating pixel map: 2.50e-01: 100%|██████████| 7/7 [00:00<00:00, 11.28it/s]\n",
-      "updating object map and translations: 2.56e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 3987.57it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3063.94it/s]\n",
-      "updating pixel map: 2.50e-01: 100%|██████████| 7/7 [00:00<00:00, 12.91it/s]\n",
-      "updating object map and translations: 2.55e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 3985.05it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3079.19it/s]\n",
-      "updating pixel map: 2.49e-01: 100%|██████████| 7/7 [00:00<00:00, 12.17it/s]\n",
-      "updating object map and translations: 2.54e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 4029.35it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3171.97it/s]\n",
-      "updating pixel map: 2.49e-01: 100%|██████████| 7/7 [00:00<00:00, 13.41it/s]\n",
-      "updating object map and translations: 2.53e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 96/96 [00:00<00:00, 4057.12it/s]\n",
-      "building object map: 100%|██████████| 96/96 [00:00<00:00, 3016.76it/s]\n",
-      "updating pixel map: 2.48e-01: 100%|██████████| 7/7 [00:00<00:00, 13.36it/s]\n",
-      "updating object map and translations: 2.53e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 2798.93it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 3530.49it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 2721.05it/s]\n",
-      "updating pixel map:   0%|          | 0/7 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Making the whitefield\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "updating pixel map: 4.66e-01: 100%|██████████| 7/7 [00:00<00:00, 11.67it/s]\n",
-      "updating object map and translations: 3.67e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 4220.39it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 3091.91it/s]\n",
-      "updating pixel map: 4.17e-01: 100%|██████████| 7/7 [00:00<00:00, 12.32it/s]\n",
-      "updating object map and translations: 3.51e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 3942.76it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 3086.75it/s]\n",
-      "updating pixel map: 4.02e-01: 100%|██████████| 7/7 [00:00<00:00, 12.24it/s]\n",
-      "updating object map and translations: 3.46e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 3613.71it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 2678.95it/s]\n",
-      "updating pixel map: 3.96e-01: 100%|██████████| 7/7 [00:00<00:00, 12.60it/s]\n",
-      "updating object map and translations: 3.44e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 4069.74it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 3083.64it/s]\n",
-      "updating pixel map: 3.94e-01: 100%|██████████| 7/7 [00:00<00:00, 12.97it/s]\n",
-      "updating object map and translations: 3.42e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 3916.91it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 2415.70it/s]\n",
-      "updating pixel map: 3.92e-01: 100%|██████████| 7/7 [00:00<00:00, 12.42it/s]\n",
-      "updating object map and translations: 3.41e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 3413.90it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 2685.19it/s]\n",
-      "updating pixel map: 3.91e-01: 100%|██████████| 7/7 [00:00<00:00, 13.24it/s]\n",
-      "updating object map and translations: 3.40e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 3591.88it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 2996.53it/s]\n",
-      "updating pixel map: 3.90e-01: 100%|██████████| 7/7 [00:00<00:00, 13.51it/s]\n",
-      "updating object map and translations: 3.39e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 4259.59it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 2844.27it/s]\n",
-      "updating pixel map: 3.89e-01: 100%|██████████| 7/7 [00:00<00:00, 13.31it/s]\n",
-      "updating object map and translations: 3.38e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 89/89 [00:00<00:00, 4029.37it/s]\n",
-      "building object map: 100%|██████████| 89/89 [00:00<00:00, 3111.76it/s]\n",
-      "updating pixel map: 3.88e-01: 100%|██████████| 7/7 [00:00<00:00, 12.17it/s]\n",
-      "updating object map and translations: 3.38e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 2913.66it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 4207.66it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 2806.49it/s]\n",
-      "updating pixel map: 6.10e-01:   0%|          | 0/7 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Making the whitefield\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "updating pixel map: 6.01e-01: 100%|██████████| 7/7 [00:00<00:00, 12.30it/s]\n",
-      "updating object map and translations: 5.16e+01:   2%|▏         | 2/100 [00:00<00:10,  9.39it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 4218.67it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 3176.55it/s]\n",
-      "updating pixel map: 5.37e-01: 100%|██████████| 7/7 [00:00<00:00, 12.48it/s]\n",
-      "updating object map and translations: 4.95e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 4100.04it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 3221.79it/s]\n",
-      "updating pixel map: 5.15e-01: 100%|██████████| 7/7 [00:00<00:00, 12.35it/s]\n",
-      "updating object map and translations: 4.90e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 3239.99it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 2530.10it/s]\n",
-      "updating pixel map: 5.10e-01: 100%|██████████| 7/7 [00:00<00:00, 12.56it/s]\n",
-      "updating object map and translations: 4.88e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 4168.27it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 3098.41it/s]\n",
-      "updating pixel map: 5.08e-01: 100%|██████████| 7/7 [00:00<00:00, 12.05it/s]\n",
-      "updating object map and translations: 4.86e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 4178.02it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 3069.70it/s]\n",
-      "updating pixel map: 5.06e-01: 100%|██████████| 7/7 [00:00<00:00, 11.79it/s]\n",
-      "updating object map and translations: 4.85e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 4229.43it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 3236.98it/s]\n",
-      "updating pixel map: 5.05e-01: 100%|██████████| 7/7 [00:00<00:00, 11.78it/s]\n",
-      "updating object map and translations: 4.84e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 3514.95it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 2718.44it/s]\n",
-      "updating pixel map: 5.04e-01: 100%|██████████| 7/7 [00:00<00:00, 11.64it/s]\n",
-      "updating object map and translations: 4.83e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 3387.24it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 2365.89it/s]\n",
-      "updating pixel map: 5.03e-01: 100%|██████████| 7/7 [00:00<00:00, 10.79it/s]\n",
-      "updating object map and translations: 4.82e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 98/98 [00:00<00:00, 3712.95it/s]\n",
-      "building object map: 100%|██████████| 98/98 [00:00<00:00, 3105.88it/s]\n",
-      "updating pixel map: 5.02e-01: 100%|██████████| 7/7 [00:00<00:00, 12.44it/s]\n",
-      "updating object map and translations: 4.81e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 2973.71it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 4301.34it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 3275.09it/s]\n",
-      "updating pixel map: 7.56e-01:   0%|          | 0/7 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Making the whitefield\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "updating pixel map: 7.44e-01: 100%|██████████| 7/7 [00:00<00:00, 14.01it/s]\n",
-      "updating object map and translations: 5.09e+01:  11%|█         | 11/100 [00:00<00:05, 16.84it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 2969.07it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 2405.33it/s]\n",
-      "updating pixel map: 6.67e-01: 100%|██████████| 7/7 [00:00<00:00, 12.04it/s]\n",
-      "updating object map and translations: 4.81e+01:   3%|▎         | 3/100 [00:00<00:06, 15.61it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 3927.49it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 3070.13it/s]\n",
-      "updating pixel map: 6.18e-01: 100%|██████████| 7/7 [00:00<00:00, 13.79it/s]\n",
-      "updating object map and translations: 4.75e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 3380.02it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 2644.88it/s]\n",
-      "updating pixel map: 6.07e-01: 100%|██████████| 7/7 [00:00<00:00, 12.12it/s]\n",
-      "updating object map and translations: 4.71e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 3309.99it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 2691.04it/s]\n",
-      "updating pixel map: 6.03e-01: 100%|██████████| 7/7 [00:00<00:00, 10.76it/s]\n",
-      "updating object map and translations: 4.69e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 3866.81it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 3046.40it/s]\n",
-      "updating pixel map: 6.01e-01: 100%|██████████| 7/7 [00:00<00:00, 13.78it/s]\n",
-      "updating object map and translations: 4.68e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 4137.70it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 3049.24it/s]\n",
-      "updating pixel map: 6.00e-01: 100%|██████████| 7/7 [00:00<00:00, 13.30it/s]\n",
-      "updating object map and translations: 4.68e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 3962.02it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 2891.22it/s]\n",
-      "updating pixel map: 5.99e-01: 100%|██████████| 7/7 [00:00<00:00, 12.87it/s]\n",
-      "updating object map and translations: 4.67e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 4010.88it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 3031.47it/s]\n",
-      "updating pixel map: 5.98e-01: 100%|██████████| 7/7 [00:00<00:00, 13.97it/s]\n",
-      "updating object map and translations: 4.66e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n",
-      "calculating errors: 100%|██████████| 78/78 [00:00<00:00, 4040.61it/s]\n",
-      "building object map: 100%|██████████| 78/78 [00:00<00:00, 3206.03it/s]\n",
-      "updating pixel map: 5.97e-01: 100%|██████████| 7/7 [00:00<00:00, 13.84it/s]\n",
-      "updating object map and translations: 4.65e+01:   0%|          | 0/100 [00:00<?, ?it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "res_dict = {}\n",
-    "p0_arr = np.array([800, 400, 200, 100])\n",
-    "for key in {1595, 1596, 1597, 1598}:\n",
-    "    cxi_path = os.path.join(exp_dir, fn_dict[key])\n",
-    "    res_dict[key] = speckle_tracking(cxi_path, df_dict[key], roi_dict[key],\n",
-    "                                     max_iter=10, phase_roi=(0,-1), search_window=(1, 300))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 83,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.colors as mcolors\n",
-    "\n",
-    "%matplotlib inline\n",
-    "key = 1596\n",
-    "fig, ax = plt.subplots(figsize=(12, 6))\n",
-    "for key, color, p0 in zip([1595, 1596, 1597, 1598], mcolors.TABLEAU_COLORS, p0_arr):\n",
-    "    ax.plot(res_dict[key]['theta'], res_dict[key]['phase'], color=color,\n",
-    "            label=r'$\\alpha$ = ' + '{:.2f} rad/mrad^3; '.format(-res_dict[key]['fit_ph'][0] * 1e-9) +\n",
-    "                  r'$T_0$ = ' + '{:d} sec'.format(p0))\n",
-    "    ax.plot(res_dict[key]['theta'], ph_model(res_dict[key]['theta'], res_dict[key]['fit_ph']),\n",
-    "                 color=color, linestyle='dashed', alpha=0.7)\n",
-    "ax.set_title('Phase', fontsize=20)\n",
-    "ax.legend(fontsize=15)\n",
-    "for ax in axes:\n",
-    "    ax.tick_params(axis='both', which='major', labelsize=12)\n",
-    "# plt.show()\n",
-    "plt.savefig('figures/phase_etime.pdf')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 81,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n",
-    "alpha_arr = np.array([res['fit_ph'][0] * 1e-9 for res in res_dict.values()])\n",
-    "r_arr = np.array([res['r_sq'] for res in res_dict.values()])\n",
-    "da_arr = np.abs(alpha_arr - alpha_arr.max()) / alpha_arr.max()\n",
-    "axes[0].scatter(p0_arr, da_arr)\n",
-    "axes[0].plot(np.linspace(p0_arr.min(), p0_arr.max()), np.zeros(50), 'r--')\n",
-    "axes[0].set_title(r'$|(\\alpha_{st} - \\alpha_{max}) / \\alpha_{max}$|', fontsize=20)\n",
-    "axes[1].scatter(p0_arr, r_arr)\n",
-    "axes[1].plot(np.linspace(p0_arr.min(), p0_arr.max()), np.ones(50), 'r--')\n",
-    "axes[1].set_title('Goodness of fit', fontsize=20)\n",
-    "axes[1].set_ylabel(r'$R^2$', fontsize=20)\n",
-    "for ax in axes:\n",
-    "    ax.tick_params(axis='both', which='major', labelsize=12)\n",
-    "    ax.set_xlabel('Exposure time, [s]', fontsize=20)\n",
-    "plt.show()\n",
-    "# plt.savefig('figures/fits_etime.pdf')"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/st_sim/__init__.py b/st_sim/__init__.py
index 3611851..a0232b1 100755
--- a/st_sim/__init__.py
+++ b/st_sim/__init__.py
@@ -5,4 +5,4 @@ st_sim - Speckle Tracking Simulation module written in cython and Python 3
 from __future__ import absolute_import
 
 from .st_wrapper import STParams, STSim, CXIProtocol, STConverter, parameters, cxi_protocol
-from .st_loader import STLoader, loader, STData, SpeckleTracking1D
+from .st_loader import STLoader, loader, STData, SpeckleTracking1D, AbberationsFit
diff --git a/st_sim/__main__.py b/st_sim/__main__.py
index 43294f9..2aaaa02 100755
--- a/st_sim/__main__.py
+++ b/st_sim/__main__.py
@@ -1,3 +1,4 @@
+from __future__ import absolute_import
 from .st_wrapper import main
 
 main()
diff --git a/st_sim/bin/beam_calc.c b/st_sim/bin/beam_calc.c
old mode 100644
new mode 100755
index 3b83f3c..a04c1e1
--- a/st_sim/bin/beam_calc.c
+++ b/st_sim/bin/beam_calc.c
@@ -1,4 +1,4 @@
-/* Generated by Cython 0.29.16 */
+/* Generated by Cython 0.29.21 */
 
 /* BEGIN: Cython Metadata
 {
@@ -42,8 +42,8 @@ END: Cython Metadata */
 #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
     #error Cython requires Python 2.6+ or Python 3.3+.
 #else
-#define CYTHON_ABI "0_29_16"
-#define CYTHON_HEX_VERSION 0x001D10F0
+#define CYTHON_ABI "0_29_21"
+#define CYTHON_HEX_VERSION 0x001D15F0
 #define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
@@ -470,7 +470,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
   #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
+  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+  #else
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+  #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
   #define PyUnicode_1BYTE_KIND  1
@@ -533,6 +537,13 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
 #ifndef PySet_CheckExact
   #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
 #endif
+#if PY_VERSION_HEX >= 0x030900A4
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
+#else
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
+#endif
 #if CYTHON_ASSUME_SAFE_MACROS
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
 #else
@@ -572,7 +583,7 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
 #endif
 #if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func))
+  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
 #else
   #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
 #endif
@@ -613,11 +624,10 @@ static CYTHON_INLINE float __PYX_NAN() {
 #define __Pyx_truncl truncl
 #endif
 
-
+#define __PYX_MARK_ERR_POS(f_index, lineno) \
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
-{ \
-  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
-}
+    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
 #ifndef __PYX_EXTERN_C
   #ifdef __cplusplus
@@ -634,6 +644,9 @@ static CYTHON_INLINE float __PYX_NAN() {
 #include <stdio.h>
 #include "numpy/arrayobject.h"
 #include "numpy/ufuncobject.h"
+
+    /* NumPy API declarations from "numpy/__init__.pxd" */
+    
 #include <math.h>
 #include "gsl/gsl_mode.h"
 #include "gsl/gsl_math.h"
@@ -959,6 +972,13 @@ static const char *__pyx_f[] = {
   "stringsource",
   "type.pxd",
 };
+/* NoFastGil.proto */
+#define __Pyx_PyGILState_Ensure PyGILState_Ensure
+#define __Pyx_PyGILState_Release PyGILState_Release
+#define __Pyx_FastGIL_Remember()
+#define __Pyx_FastGIL_Forget()
+#define __Pyx_FastGilFuncInit()
+
 /* MemviewSliceStruct.proto */
 struct __pyx_memoryview_obj;
 typedef struct {
@@ -1019,13 +1039,6 @@ typedef volatile __pyx_atomic_int_type __pyx_atomic_int;
             __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
 #endif
 
-/* NoFastGil.proto */
-#define __Pyx_PyGILState_Ensure PyGILState_Ensure
-#define __Pyx_PyGILState_Release PyGILState_Release
-#define __Pyx_FastGIL_Remember()
-#define __Pyx_FastGIL_Forget()
-#define __Pyx_FastGilFuncInit()
-
 /* ForceInitThreads.proto */
 #ifndef __PYX_FORCE_INIT_THREADS
   #define __PYX_FORCE_INIT_THREADS 0
@@ -1068,7 +1081,7 @@ typedef struct {
 } __Pyx_BufFmt_Context;
 
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":697
  * # in Cython to enable them only on the right systems.
  * 
  * ctypedef npy_int8       int8_t             # <<<<<<<<<<<<<<
@@ -1077,7 +1090,7 @@ typedef struct {
  */
 typedef npy_int8 __pyx_t_5numpy_int8_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":698
  * 
  * ctypedef npy_int8       int8_t
  * ctypedef npy_int16      int16_t             # <<<<<<<<<<<<<<
@@ -1086,7 +1099,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t;
  */
 typedef npy_int16 __pyx_t_5numpy_int16_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":699
  * ctypedef npy_int8       int8_t
  * ctypedef npy_int16      int16_t
  * ctypedef npy_int32      int32_t             # <<<<<<<<<<<<<<
@@ -1095,7 +1108,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t;
  */
 typedef npy_int32 __pyx_t_5numpy_int32_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":779
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":700
  * ctypedef npy_int16      int16_t
  * ctypedef npy_int32      int32_t
  * ctypedef npy_int64      int64_t             # <<<<<<<<<<<<<<
@@ -1104,7 +1117,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t;
  */
 typedef npy_int64 __pyx_t_5numpy_int64_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":704
  * #ctypedef npy_int128     int128_t
  * 
  * ctypedef npy_uint8      uint8_t             # <<<<<<<<<<<<<<
@@ -1113,7 +1126,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t;
  */
 typedef npy_uint8 __pyx_t_5numpy_uint8_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":705
  * 
  * ctypedef npy_uint8      uint8_t
  * ctypedef npy_uint16     uint16_t             # <<<<<<<<<<<<<<
@@ -1122,7 +1135,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t;
  */
 typedef npy_uint16 __pyx_t_5numpy_uint16_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":706
  * ctypedef npy_uint8      uint8_t
  * ctypedef npy_uint16     uint16_t
  * ctypedef npy_uint32     uint32_t             # <<<<<<<<<<<<<<
@@ -1131,7 +1144,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t;
  */
 typedef npy_uint32 __pyx_t_5numpy_uint32_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":786
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":707
  * ctypedef npy_uint16     uint16_t
  * ctypedef npy_uint32     uint32_t
  * ctypedef npy_uint64     uint64_t             # <<<<<<<<<<<<<<
@@ -1140,7 +1153,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t;
  */
 typedef npy_uint64 __pyx_t_5numpy_uint64_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":711
  * #ctypedef npy_uint128    uint128_t
  * 
  * ctypedef npy_float32    float32_t             # <<<<<<<<<<<<<<
@@ -1149,7 +1162,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t;
  */
 typedef npy_float32 __pyx_t_5numpy_float32_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":791
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":712
  * 
  * ctypedef npy_float32    float32_t
  * ctypedef npy_float64    float64_t             # <<<<<<<<<<<<<<
@@ -1158,7 +1171,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t;
  */
 typedef npy_float64 __pyx_t_5numpy_float64_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":721
  * # The int types are mapped a bit surprising --
  * # numpy.int corresponds to 'l' and numpy.long to 'q'
  * ctypedef npy_long       int_t             # <<<<<<<<<<<<<<
@@ -1167,7 +1180,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t;
  */
 typedef npy_long __pyx_t_5numpy_int_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":722
  * # numpy.int corresponds to 'l' and numpy.long to 'q'
  * ctypedef npy_long       int_t
  * ctypedef npy_longlong   long_t             # <<<<<<<<<<<<<<
@@ -1176,7 +1189,7 @@ typedef npy_long __pyx_t_5numpy_int_t;
  */
 typedef npy_longlong __pyx_t_5numpy_long_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":802
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":723
  * ctypedef npy_long       int_t
  * ctypedef npy_longlong   long_t
  * ctypedef npy_longlong   longlong_t             # <<<<<<<<<<<<<<
@@ -1185,7 +1198,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t;
  */
 typedef npy_longlong __pyx_t_5numpy_longlong_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":725
  * ctypedef npy_longlong   longlong_t
  * 
  * ctypedef npy_ulong      uint_t             # <<<<<<<<<<<<<<
@@ -1194,7 +1207,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t;
  */
 typedef npy_ulong __pyx_t_5numpy_uint_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":726
  * 
  * ctypedef npy_ulong      uint_t
  * ctypedef npy_ulonglong  ulong_t             # <<<<<<<<<<<<<<
@@ -1203,7 +1216,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t;
  */
 typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":806
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":727
  * ctypedef npy_ulong      uint_t
  * ctypedef npy_ulonglong  ulong_t
  * ctypedef npy_ulonglong  ulonglong_t             # <<<<<<<<<<<<<<
@@ -1212,7 +1225,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
  */
 typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":729
  * ctypedef npy_ulonglong  ulonglong_t
  * 
  * ctypedef npy_intp       intp_t             # <<<<<<<<<<<<<<
@@ -1221,7 +1234,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
  */
 typedef npy_intp __pyx_t_5numpy_intp_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":809
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":730
  * 
  * ctypedef npy_intp       intp_t
  * ctypedef npy_uintp      uintp_t             # <<<<<<<<<<<<<<
@@ -1230,7 +1243,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t;
  */
 typedef npy_uintp __pyx_t_5numpy_uintp_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":732
  * ctypedef npy_uintp      uintp_t
  * 
  * ctypedef npy_double     float_t             # <<<<<<<<<<<<<<
@@ -1239,7 +1252,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t;
  */
 typedef npy_double __pyx_t_5numpy_float_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":733
  * 
  * ctypedef npy_double     float_t
  * ctypedef npy_double     double_t             # <<<<<<<<<<<<<<
@@ -1248,7 +1261,7 @@ typedef npy_double __pyx_t_5numpy_float_t;
  */
 typedef npy_double __pyx_t_5numpy_double_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":813
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":734
  * ctypedef npy_double     float_t
  * ctypedef npy_double     double_t
  * ctypedef npy_longdouble longdouble_t             # <<<<<<<<<<<<<<
@@ -1279,31 +1292,22 @@ typedef int __pyx_t_10cython_gsl_size_t;
  * 
  * ctypedef cnp.complex128_t complex_t
  * ctypedef cnp.float64_t float_t             # <<<<<<<<<<<<<<
- * ctypedef cnp.float32_t float32_t
  * ctypedef cnp.int64_t int_t
+ * ctypedef cnp.uint64_t uint_t
  */
 typedef __pyx_t_5numpy_float64_t __pyx_t_9beam_calc_float_t;
 
 /* "beam_calc.pyx":10
  * ctypedef cnp.complex128_t complex_t
  * ctypedef cnp.float64_t float_t
- * ctypedef cnp.float32_t float32_t             # <<<<<<<<<<<<<<
- * ctypedef cnp.int64_t int_t
- * ctypedef cnp.uint64_t uint_t
- */
-typedef __pyx_t_5numpy_float32_t __pyx_t_9beam_calc_float32_t;
-
-/* "beam_calc.pyx":11
- * ctypedef cnp.float64_t float_t
- * ctypedef cnp.float32_t float32_t
  * ctypedef cnp.int64_t int_t             # <<<<<<<<<<<<<<
  * ctypedef cnp.uint64_t uint_t
  * ctypedef cnp.uint8_t uint8_t
  */
 typedef __pyx_t_5numpy_int64_t __pyx_t_9beam_calc_int_t;
 
-/* "beam_calc.pyx":12
- * ctypedef cnp.float32_t float32_t
+/* "beam_calc.pyx":11
+ * ctypedef cnp.float64_t float_t
  * ctypedef cnp.int64_t int_t
  * ctypedef cnp.uint64_t uint_t             # <<<<<<<<<<<<<<
  * ctypedef cnp.uint8_t uint8_t
@@ -1311,7 +1315,7 @@ typedef __pyx_t_5numpy_int64_t __pyx_t_9beam_calc_int_t;
  */
 typedef __pyx_t_5numpy_uint64_t __pyx_t_9beam_calc_uint_t;
 
-/* "beam_calc.pyx":13
+/* "beam_calc.pyx":12
  * ctypedef cnp.int64_t int_t
  * ctypedef cnp.uint64_t uint_t
  * ctypedef cnp.uint8_t uint8_t             # <<<<<<<<<<<<<<
@@ -1362,7 +1366,7 @@ struct __pyx_MemviewEnum_obj;
 struct __pyx_memoryview_obj;
 struct __pyx_memoryviewslice_obj;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":736
  * ctypedef npy_longdouble longdouble_t
  * 
  * ctypedef npy_cfloat      cfloat_t             # <<<<<<<<<<<<<<
@@ -1371,7 +1375,7 @@ struct __pyx_memoryviewslice_obj;
  */
 typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":737
  * 
  * ctypedef npy_cfloat      cfloat_t
  * ctypedef npy_cdouble     cdouble_t             # <<<<<<<<<<<<<<
@@ -1380,7 +1384,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
  */
 typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":817
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":738
  * ctypedef npy_cfloat      cfloat_t
  * ctypedef npy_cdouble     cdouble_t
  * ctypedef npy_clongdouble clongdouble_t             # <<<<<<<<<<<<<<
@@ -1389,7 +1393,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
  */
 typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":819
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":740
  * ctypedef npy_clongdouble clongdouble_t
  * 
  * ctypedef npy_cdouble     complex_t             # <<<<<<<<<<<<<<
@@ -1811,9 +1815,6 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
-/* RaiseException.proto */
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
-
 /* DictGetItem.proto */
 #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
 static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
@@ -1837,6 +1838,9 @@ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
 /* ExtTypeTest.proto */
 static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
 
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
 /* GetTopmostException.proto */
 #if CYTHON_USE_EXC_INFO_STACK
 static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
@@ -1985,7 +1989,7 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
     if (likely(L->allocated > len)) {
         Py_INCREF(x);
         PyList_SET_ITEM(list, len, x);
-        Py_SIZE(list) = len+1;
+        __Pyx_SET_SIZE(list, len + 1);
         return 0;
     }
     return PyList_Append(list, x);
@@ -2023,7 +2027,7 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
     if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
         Py_INCREF(x);
         PyList_SET_ITEM(list, len, x);
-        Py_SIZE(list) = len+1;
+        __Pyx_SET_SIZE(list, len + 1);
         return 0;
     }
     return PyList_Append(list, x);
@@ -2058,6 +2062,9 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 /* SetVTable.proto */
 static int __Pyx_SetVtable(PyObject *dict, void *vtable);
 
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
 /* SetupReduce.proto */
 static int __Pyx_setup_reduce(PyObject* type_obj);
 
@@ -2075,7 +2082,7 @@ static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name,
 /* FetchCommonType.proto */
 static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
 
-/* CythonFunction.proto */
+/* CythonFunctionShared.proto */
 #define __Pyx_CyFunction_USED 1
 #define __Pyx_CYFUNCTION_STATICMETHOD  0x01
 #define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
@@ -2112,9 +2119,7 @@ typedef struct {
 } __pyx_CyFunctionObject;
 static PyTypeObject *__pyx_CyFunctionType = 0;
 #define __Pyx_CyFunction_Check(obj)  (__Pyx_TypeCheck(obj, __pyx_CyFunctionType))
-#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\
-    __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code)
-static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml,
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
                                       int flags, PyObject* qualname,
                                       PyObject *self,
                                       PyObject *module, PyObject *globals,
@@ -2130,6 +2135,13 @@ static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
                                                               PyObject *dict);
 static int __pyx_CyFunction_init(void);
 
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
 /* CLineInTraceback.proto */
 #ifdef CYTHON_CLINE_IN_TRACEBACK
 #define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
@@ -2214,10 +2226,10 @@ static int __Pyx_ValidateAndInit_memviewslice(
                 PyObject *original_obj);
 
 /* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(PyObject *, int writable_flag);
+static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(PyObject *, int writable_flag);
 
 /* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(PyObject *, int writable_flag);
+static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(PyObject *, int writable_flag);
 
 /* ObjectToMemviewSlice.proto */
 static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc___pyx_t_double_complex(PyObject *, int writable_flag);
@@ -2629,12 +2641,12 @@ static PyObject *contiguous = 0;
 static PyObject *indirect_contiguous = 0;
 static int __pyx_memoryview_thread_locks_used;
 static PyThread_type_lock __pyx_memoryview_thread_locks[8];
+static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_gsl_quad(gsl_function, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_int_t); /*proto*/
 static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_lens_re(__pyx_t_9beam_calc_float_t, void *); /*proto*/
 static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_lens_im(__pyx_t_9beam_calc_float_t, void *); /*proto*/
+static __pyx_t_double_complex __pyx_f_9beam_calc_lens_wp(__pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t); /*proto*/
 static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_aperture_re(__pyx_t_9beam_calc_float_t, void *); /*proto*/
 static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_aperture_im(__pyx_t_9beam_calc_float_t, void *); /*proto*/
-static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_gsl_quad(gsl_function, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_int_t); /*proto*/
-static __pyx_t_double_complex __pyx_f_9beam_calc_lens_wp(__pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t); /*proto*/
 static __pyx_t_double_complex __pyx_f_9beam_calc_aperture_wp(__pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t); /*proto*/
 static __pyx_t_double_complex __pyx_f_9beam_calc_fhf_wp(__Pyx_memviewslice, __Pyx_memviewslice, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t); /*proto*/
 static void __pyx_f_9beam_calc_fhf_1d(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t); /*proto*/
@@ -2642,7 +2654,7 @@ static __pyx_t_double_complex __pyx_f_9beam_calc_fnl_wp(__Pyx_memviewslice, __Py
 static void __pyx_f_9beam_calc_fnl_1d(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t); /*proto*/
 static __pyx_t_9beam_calc_int_t __pyx_f_9beam_calc_binary_search(__Pyx_memviewslice, __pyx_t_9beam_calc_int_t, __pyx_t_9beam_calc_int_t, __pyx_t_9beam_calc_float_t); /*proto*/
 static __pyx_t_9beam_calc_int_t __pyx_f_9beam_calc_searchsorted(__Pyx_memviewslice, __pyx_t_9beam_calc_float_t); /*proto*/
-static void __pyx_f_9beam_calc_barcode_1d(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t); /*proto*/
+static void __pyx_f_9beam_calc_barcode_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t, __pyx_t_9beam_calc_float_t); /*proto*/
 static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_convolve_c(__Pyx_memviewslice, __Pyx_memviewslice, __pyx_t_9beam_calc_int_t); /*proto*/
 static void __pyx_f_9beam_calc_make_frame_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __pyx_t_9beam_calc_float_t, unsigned long); /*proto*/
 static __pyx_t_9beam_calc_uint_t __pyx_f_9beam_calc_wirthselect_uint(__Pyx_memviewslice, int); /*proto*/
@@ -2679,8 +2691,8 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_
 static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/
 static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/
 static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/
-static __Pyx_TypeInfo __Pyx_TypeInfo___pyx_t_double_complex = { "double complex", NULL, sizeof(__pyx_t_double_complex), { 0 }, 0, 'C', 0, 0 };
 static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_9beam_calc_float_t = { "float_t", NULL, sizeof(__pyx_t_9beam_calc_float_t), { 0 }, 0, 'R', 0, 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo___pyx_t_double_complex = { "double complex", NULL, sizeof(__pyx_t_double_complex), { 0 }, 0, 'C', 0, 0 };
 static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_9beam_calc_uint_t = { "uint_t", NULL, sizeof(__pyx_t_9beam_calc_uint_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_9beam_calc_uint_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_9beam_calc_uint_t), 0 };
 static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_9beam_calc_uint8_t = { "uint8_t", NULL, sizeof(__pyx_t_9beam_calc_uint8_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_9beam_calc_uint8_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_9beam_calc_uint8_t), 0 };
 #define __Pyx_MODULE_NAME "beam_calc"
@@ -2689,8 +2701,8 @@ int __pyx_module_is_main_beam_calc = 0;
 
 /* Implementation of 'beam_calc' */
 static PyObject *__pyx_builtin_range;
-static PyObject *__pyx_builtin_ValueError;
 static PyObject *__pyx_builtin_RuntimeError;
+static PyObject *__pyx_builtin_ValueError;
 static PyObject *__pyx_builtin_ImportError;
 static PyObject *__pyx_builtin_MemoryError;
 static PyObject *__pyx_builtin_enumerate;
@@ -2715,6 +2727,8 @@ static const char __pyx_k_rd[] = "rd";
 static const char __pyx_k_ss[] = "ss";
 static const char __pyx_k_wf[] = "wf";
 static const char __pyx_k_wl[] = "wl";
+static const char __pyx_k_x0[] = "x0";
+static const char __pyx_k_x1[] = "x1";
 static const char __pyx_k_atn[] = "atn";
 static const char __pyx_k_i_x[] = "i_x";
 static const char __pyx_k_i_y[] = "i_y";
@@ -2722,8 +2736,8 @@ static const char __pyx_k_new[] = "__new__";
 static const char __pyx_k_obj[] = "obj";
 static const char __pyx_k_sgm[] = "sgm";
 static const char __pyx_k_wf0[] = "wf0";
+static const char __pyx_k_atn0[] = "atn0";
 static const char __pyx_k_base[] = "base";
-static const char __pyx_k_bc_t[] = "bc_t";
 static const char __pyx_k_br_n[] = "br_n";
 static const char __pyx_k_data[] = "data";
 static const char __pyx_k_dict[] = "__dict__";
@@ -2746,8 +2760,8 @@ static const char __pyx_k_test[] = "__test__";
 static const char __pyx_k_ASCII[] = "ASCII";
 static const char __pyx_k_alpha[] = "alpha";
 static const char __pyx_k_array[] = "array";
-static const char __pyx_k_bm_dx[] = "bm_dx";
 static const char __pyx_k_br_dx[] = "br_dx";
+static const char __pyx_k_br_tr[] = "br_tr";
 static const char __pyx_k_class[] = "__class__";
 static const char __pyx_k_defoc[] = "defoc";
 static const char __pyx_k_dtype[] = "dtype";
@@ -2776,7 +2790,6 @@ static const char __pyx_k_unpack[] = "unpack";
 static const char __pyx_k_update[] = "update";
 static const char __pyx_k_xx_arr[] = "xx_arr";
 static const char __pyx_k_asarray[] = "asarray";
-static const char __pyx_k_barcode[] = "barcode";
 static const char __pyx_k_float64[] = "float64";
 static const char __pyx_k_fortran[] = "fortran";
 static const char __pyx_k_memview[] = "memview";
@@ -2795,6 +2808,8 @@ static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
 static const char __pyx_k_IndexError[] = "IndexError";
 static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_barcode_1d[] = "barcode_1d";
+static const char __pyx_k_barcode_2d[] = "barcode_2d";
 static const char __pyx_k_complex128[] = "complex128";
 static const char __pyx_k_fresnel_1d[] = "fresnel_1d";
 static const char __pyx_k_fresnel_2d[] = "fresnel_2d";
@@ -2831,7 +2846,6 @@ static const char __pyx_k_contiguous_and_indirect[] = "<contiguous and indirect>
 static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'";
 static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d.";
 static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array";
-static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
 static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data.";
 static const char __pyx_k_strided_and_direct_or_indirect[] = "<strided and direct or indirect>";
 static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
@@ -2849,7 +2863,6 @@ static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte
 static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)";
 static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object";
 static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)";
-static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
 static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import";
 static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides.";
@@ -2890,16 +2903,17 @@ static PyObject *__pyx_n_s_aperture;
 static PyObject *__pyx_n_s_array;
 static PyObject *__pyx_n_s_asarray;
 static PyObject *__pyx_n_s_atn;
+static PyObject *__pyx_n_s_atn0;
 static PyObject *__pyx_n_s_b;
-static PyObject *__pyx_n_s_barcode;
+static PyObject *__pyx_n_s_barcode_1d;
+static PyObject *__pyx_n_s_barcode_2d;
 static PyObject *__pyx_n_s_barcode_steps;
 static PyObject *__pyx_n_s_base;
-static PyObject *__pyx_n_s_bc_t;
 static PyObject *__pyx_n_s_beam_calc;
 static PyObject *__pyx_kp_s_beam_calc_pyx;
-static PyObject *__pyx_n_s_bm_dx;
 static PyObject *__pyx_n_s_br_dx;
 static PyObject *__pyx_n_s_br_n;
+static PyObject *__pyx_n_s_br_tr;
 static PyObject *__pyx_n_s_bs_max;
 static PyObject *__pyx_n_s_bs_min;
 static PyObject *__pyx_n_s_bx_arr;
@@ -2953,8 +2967,6 @@ static PyObject *__pyx_n_s_memview;
 static PyObject *__pyx_n_s_mode;
 static PyObject *__pyx_n_s_name;
 static PyObject *__pyx_n_s_name_2;
-static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
-static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
 static PyObject *__pyx_n_s_ndim;
 static PyObject *__pyx_n_s_new;
 static PyObject *__pyx_n_s_nf;
@@ -3009,21 +3021,22 @@ static PyObject *__pyx_n_s_wave_arr;
 static PyObject *__pyx_n_s_wf;
 static PyObject *__pyx_n_s_wf0;
 static PyObject *__pyx_n_s_wl;
+static PyObject *__pyx_n_s_x0;
+static PyObject *__pyx_n_s_x1;
 static PyObject *__pyx_n_s_x_arr;
 static PyObject *__pyx_n_s_xx_arr;
 static PyObject *__pyx_n_s_z;
-static PyObject *__pyx_pf_9beam_calc_fraunhofer_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl); /* proto */
-static PyObject *__pyx_pf_9beam_calc_2fraunhofer_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl); /* proto */
-static PyObject *__pyx_pf_9beam_calc_4fresnel_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl); /* proto */
-static PyObject *__pyx_pf_9beam_calc_6fresnel_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl); /* proto */
-static PyObject *__pyx_pf_9beam_calc_8aperture(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_z, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap); /* proto */
-static PyObject *__pyx_pf_9beam_calc_10lens(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap, __pyx_t_9beam_calc_float_t __pyx_v_focus, __pyx_t_9beam_calc_float_t __pyx_v_defoc, __pyx_t_9beam_calc_float_t __pyx_v_alpha); /* proto */
-static PyObject *__pyx_pf_9beam_calc_12barcode_steps(CYTHON_UNUSED PyObject *__pyx_self, __pyx_t_9beam_calc_float_t __pyx_v_bm_dx, __pyx_t_9beam_calc_float_t __pyx_v_br_dx, __pyx_t_9beam_calc_float_t __pyx_v_rd, __pyx_t_9beam_calc_float_t __pyx_v_ss, __pyx_t_9beam_calc_int_t __pyx_v_nf); /* proto */
-static PyObject *__pyx_pf_9beam_calc_14barcode(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_bx_arr, __pyx_t_9beam_calc_float_t __pyx_v_sgm, __pyx_t_9beam_calc_float_t __pyx_v_atn, __pyx_t_9beam_calc_float_t __pyx_v_ss, __pyx_t_9beam_calc_int_t __pyx_v_nf); /* proto */
-static PyObject *__pyx_pf_9beam_calc_16make_frames(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_i_x, __Pyx_memviewslice __pyx_v_i_y, __Pyx_memviewslice __pyx_v_sc_x, __Pyx_memviewslice __pyx_v_sc_y, __pyx_t_9beam_calc_float_t __pyx_v_pix_size); /* proto */
-static PyObject *__pyx_pf_9beam_calc_18make_whitefield(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_data, __Pyx_memviewslice __pyx_v_mask); /* proto */
-static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
-static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
+static PyObject *__pyx_pf_9beam_calc_lens(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap, __pyx_t_9beam_calc_float_t __pyx_v_focus, __pyx_t_9beam_calc_float_t __pyx_v_defoc, __pyx_t_9beam_calc_float_t __pyx_v_alpha, __pyx_t_9beam_calc_float_t __pyx_v_x0); /* proto */
+static PyObject *__pyx_pf_9beam_calc_2aperture(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_z, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap); /* proto */
+static PyObject *__pyx_pf_9beam_calc_4fraunhofer_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl); /* proto */
+static PyObject *__pyx_pf_9beam_calc_6fraunhofer_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl); /* proto */
+static PyObject *__pyx_pf_9beam_calc_8fresnel_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl); /* proto */
+static PyObject *__pyx_pf_9beam_calc_10fresnel_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl); /* proto */
+static PyObject *__pyx_pf_9beam_calc_12barcode_steps(CYTHON_UNUSED PyObject *__pyx_self, __pyx_t_9beam_calc_float_t __pyx_v_x0, __pyx_t_9beam_calc_float_t __pyx_v_x1, __pyx_t_9beam_calc_float_t __pyx_v_br_dx, __pyx_t_9beam_calc_float_t __pyx_v_rd); /* proto */
+static PyObject *__pyx_pf_9beam_calc_14barcode_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_bx_arr, __pyx_t_9beam_calc_float_t __pyx_v_sgm, __pyx_t_9beam_calc_float_t __pyx_v_atn0, __pyx_t_9beam_calc_float_t __pyx_v_atn); /* proto */
+static PyObject *__pyx_pf_9beam_calc_16barcode_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_bx_arr, __pyx_t_9beam_calc_float_t __pyx_v_sgm, __pyx_t_9beam_calc_float_t __pyx_v_atn0, __pyx_t_9beam_calc_float_t __pyx_v_atn, __pyx_t_9beam_calc_float_t __pyx_v_ss, __pyx_t_9beam_calc_int_t __pyx_v_nf); /* proto */
+static PyObject *__pyx_pf_9beam_calc_18make_frames(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_i_x, __Pyx_memviewslice __pyx_v_i_y, __Pyx_memviewslice __pyx_v_sc_x, __Pyx_memviewslice __pyx_v_sc_y, __pyx_t_9beam_calc_float_t __pyx_v_pix_size); /* proto */
+static PyObject *__pyx_pf_9beam_calc_20make_whitefield(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_data, __Pyx_memviewslice __pyx_v_mask); /* proto */
 static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */
 static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
 static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */
@@ -3083,7 +3096,7 @@ static PyObject *__pyx_tuple__6;
 static PyObject *__pyx_tuple__7;
 static PyObject *__pyx_tuple__8;
 static PyObject *__pyx_tuple__9;
-static PyObject *__pyx_slice__22;
+static PyObject *__pyx_slice__20;
 static PyObject *__pyx_tuple__10;
 static PyObject *__pyx_tuple__11;
 static PyObject *__pyx_tuple__12;
@@ -3094,11 +3107,10 @@ static PyObject *__pyx_tuple__16;
 static PyObject *__pyx_tuple__17;
 static PyObject *__pyx_tuple__18;
 static PyObject *__pyx_tuple__19;
-static PyObject *__pyx_tuple__20;
 static PyObject *__pyx_tuple__21;
+static PyObject *__pyx_tuple__22;
 static PyObject *__pyx_tuple__23;
 static PyObject *__pyx_tuple__24;
-static PyObject *__pyx_tuple__25;
 static PyObject *__pyx_tuple__26;
 static PyObject *__pyx_tuple__28;
 static PyObject *__pyx_tuple__30;
@@ -3115,6 +3127,7 @@ static PyObject *__pyx_tuple__48;
 static PyObject *__pyx_tuple__49;
 static PyObject *__pyx_tuple__50;
 static PyObject *__pyx_tuple__51;
+static PyObject *__pyx_codeobj__25;
 static PyObject *__pyx_codeobj__27;
 static PyObject *__pyx_codeobj__29;
 static PyObject *__pyx_codeobj__31;
@@ -3128,9 +3141,73 @@ static PyObject *__pyx_codeobj__45;
 static PyObject *__pyx_codeobj__52;
 /* Late includes */
 
-/* "beam_calc.pyx":16
+/* "beam_calc.pyx":15
+ * DEF X_TOL = 4.320005384913445 # Y_TOL = 1e-9
+ * 
+ * cdef float_t gsl_quad(gsl_function func, float_t a, float_t b, float_t eps_abs, float_t eps_rel, int_t limit) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         float_t result, error
+ */
+
+static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_gsl_quad(gsl_function __pyx_v_func, __pyx_t_9beam_calc_float_t __pyx_v_a, __pyx_t_9beam_calc_float_t __pyx_v_b, __pyx_t_9beam_calc_float_t __pyx_v_eps_abs, __pyx_t_9beam_calc_float_t __pyx_v_eps_rel, __pyx_t_9beam_calc_int_t __pyx_v_limit) {
+  __pyx_t_9beam_calc_float_t __pyx_v_result;
+  __pyx_t_9beam_calc_float_t __pyx_v_error;
+  gsl_integration_workspace *__pyx_v_W;
+  __pyx_t_9beam_calc_float_t __pyx_r;
+
+  /* "beam_calc.pyx":19
+ *         float_t result, error
+ *         gsl_integration_workspace * W
+ *     W = gsl_integration_workspace_alloc(limit)             # <<<<<<<<<<<<<<
+ *     gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)
+ *     gsl_integration_workspace_free(W)
+ */
+  __pyx_v_W = gsl_integration_workspace_alloc(__pyx_v_limit);
+
+  /* "beam_calc.pyx":20
+ *         gsl_integration_workspace * W
+ *     W = gsl_integration_workspace_alloc(limit)
+ *     gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)             # <<<<<<<<<<<<<<
+ *     gsl_integration_workspace_free(W)
+ *     return result
+ */
+  (void)(gsl_integration_qag((&__pyx_v_func), __pyx_v_a, __pyx_v_b, __pyx_v_eps_abs, __pyx_v_eps_rel, __pyx_v_limit, GSL_INTEG_GAUSS51, __pyx_v_W, (&__pyx_v_result), (&__pyx_v_error)));
+
+  /* "beam_calc.pyx":21
+ *     W = gsl_integration_workspace_alloc(limit)
+ *     gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)
+ *     gsl_integration_workspace_free(W)             # <<<<<<<<<<<<<<
+ *     return result
+ * 
+ */
+  gsl_integration_workspace_free(__pyx_v_W);
+
+  /* "beam_calc.pyx":22
+ *     gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)
+ *     gsl_integration_workspace_free(W)
+ *     return result             # <<<<<<<<<<<<<<
+ * 
+ * cdef float_t lens_re(float_t xx, void* params) nogil:
+ */
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
+  /* "beam_calc.pyx":15
  * DEF X_TOL = 4.320005384913445 # Y_TOL = 1e-9
  * 
+ * cdef float_t gsl_quad(gsl_function func, float_t a, float_t b, float_t eps_abs, float_t eps_rel, int_t limit) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         float_t result, error
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":24
+ *     return result
+ * 
  * cdef float_t lens_re(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
  *     cdef:
  *         float_t x = (<float_t*> params)[0], wl = (<float_t*> params)[1]
@@ -3142,60 +3219,62 @@ static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_lens_re(__pyx_t_9beam_calc_
   __pyx_t_9beam_calc_float_t __pyx_v_f;
   __pyx_t_9beam_calc_float_t __pyx_v_df;
   __pyx_t_9beam_calc_float_t __pyx_v_a;
+  __pyx_t_9beam_calc_float_t __pyx_v_x0;
   __pyx_t_9beam_calc_float_t __pyx_v_ph;
   __pyx_t_9beam_calc_float_t __pyx_v_ph_ab;
   __pyx_t_9beam_calc_float_t __pyx_r;
 
-  /* "beam_calc.pyx":18
+  /* "beam_calc.pyx":26
  * cdef float_t lens_re(float_t xx, void* params) nogil:
  *     cdef:
  *         float_t x = (<float_t*> params)[0], wl = (<float_t*> params)[1]             # <<<<<<<<<<<<<<
  *         float_t f = (<float_t*> params)[2], df = (<float_t*> params)[3]
- *         float_t a = (<float_t*> params)[4]
+ *         float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]
  */
   __pyx_v_x = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[0]);
   __pyx_v_wl = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[1]);
 
-  /* "beam_calc.pyx":19
+  /* "beam_calc.pyx":27
  *     cdef:
  *         float_t x = (<float_t*> params)[0], wl = (<float_t*> params)[1]
  *         float_t f = (<float_t*> params)[2], df = (<float_t*> params)[3]             # <<<<<<<<<<<<<<
- *         float_t a = (<float_t*> params)[4]
+ *         float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]
  *         float_t ph, ph_ab
  */
   __pyx_v_f = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[2]);
   __pyx_v_df = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[3]);
 
-  /* "beam_calc.pyx":20
+  /* "beam_calc.pyx":28
  *         float_t x = (<float_t*> params)[0], wl = (<float_t*> params)[1]
  *         float_t f = (<float_t*> params)[2], df = (<float_t*> params)[3]
- *         float_t a = (<float_t*> params)[4]             # <<<<<<<<<<<<<<
+ *         float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]             # <<<<<<<<<<<<<<
  *         float_t ph, ph_ab
  *     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx
  */
   __pyx_v_a = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[4]);
+  __pyx_v_x0 = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[5]);
 
-  /* "beam_calc.pyx":22
- *         float_t a = (<float_t*> params)[4]
+  /* "beam_calc.pyx":30
+ *         float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]
  *         float_t ph, ph_ab
  *     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx             # <<<<<<<<<<<<<<
- *     ph_ab = -a * 1e9 * (xx / f)**3
+ *     ph_ab = -a * 1e9 * ((xx - x0) / f)**3
  *     return cos(ph + ph_ab)
  */
   __pyx_v_ph = (((((((-M_PI) * pow(__pyx_v_xx, 2.0)) / __pyx_v_wl) * __pyx_v_df) / __pyx_v_f) / (__pyx_v_f + __pyx_v_df)) - ((((((__pyx_t_9beam_calc_float_t)(2.0 * M_PI)) / __pyx_v_wl) / (__pyx_v_f + __pyx_v_df)) * __pyx_v_x) * __pyx_v_xx));
 
-  /* "beam_calc.pyx":23
+  /* "beam_calc.pyx":31
  *         float_t ph, ph_ab
  *     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx
- *     ph_ab = -a * 1e9 * (xx / f)**3             # <<<<<<<<<<<<<<
+ *     ph_ab = -a * 1e9 * ((xx - x0) / f)**3             # <<<<<<<<<<<<<<
  *     return cos(ph + ph_ab)
  * 
  */
-  __pyx_v_ph_ab = (((-__pyx_v_a) * 1e9) * pow((__pyx_v_xx / __pyx_v_f), 3.0));
+  __pyx_v_ph_ab = (((-__pyx_v_a) * 1e9) * pow(((__pyx_v_xx - __pyx_v_x0) / __pyx_v_f), 3.0));
 
-  /* "beam_calc.pyx":24
+  /* "beam_calc.pyx":32
  *     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx
- *     ph_ab = -a * 1e9 * (xx / f)**3
+ *     ph_ab = -a * 1e9 * ((xx - x0) / f)**3
  *     return cos(ph + ph_ab)             # <<<<<<<<<<<<<<
  * 
  * cdef float_t lens_im(float_t xx, void* params) nogil:
@@ -3203,8 +3282,8 @@ static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_lens_re(__pyx_t_9beam_calc_
   __pyx_r = cos((__pyx_v_ph + __pyx_v_ph_ab));
   goto __pyx_L0;
 
-  /* "beam_calc.pyx":16
- * DEF X_TOL = 4.320005384913445 # Y_TOL = 1e-9
+  /* "beam_calc.pyx":24
+ *     return result
  * 
  * cdef float_t lens_re(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
  *     cdef:
@@ -3216,7 +3295,7 @@ static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_lens_re(__pyx_t_9beam_calc_
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":26
+/* "beam_calc.pyx":34
  *     return cos(ph + ph_ab)
  * 
  * cdef float_t lens_im(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
@@ -3230,68 +3309,70 @@ static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_lens_im(__pyx_t_9beam_calc_
   __pyx_t_9beam_calc_float_t __pyx_v_f;
   __pyx_t_9beam_calc_float_t __pyx_v_df;
   __pyx_t_9beam_calc_float_t __pyx_v_a;
+  __pyx_t_9beam_calc_float_t __pyx_v_x0;
   __pyx_t_9beam_calc_float_t __pyx_v_ph;
   __pyx_t_9beam_calc_float_t __pyx_v_ph_ab;
   __pyx_t_9beam_calc_float_t __pyx_r;
 
-  /* "beam_calc.pyx":28
+  /* "beam_calc.pyx":36
  * cdef float_t lens_im(float_t xx, void* params) nogil:
  *     cdef:
  *         float_t x = (<float_t*> params)[0], wl = (<float_t*> params)[1]             # <<<<<<<<<<<<<<
  *         float_t f = (<float_t*> params)[2], df = (<float_t*> params)[3]
- *         float_t a = (<float_t*> params)[4]
+ *         float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]
  */
   __pyx_v_x = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[0]);
   __pyx_v_wl = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[1]);
 
-  /* "beam_calc.pyx":29
+  /* "beam_calc.pyx":37
  *     cdef:
  *         float_t x = (<float_t*> params)[0], wl = (<float_t*> params)[1]
  *         float_t f = (<float_t*> params)[2], df = (<float_t*> params)[3]             # <<<<<<<<<<<<<<
- *         float_t a = (<float_t*> params)[4]
+ *         float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]
  *         float_t ph, ph_ab
  */
   __pyx_v_f = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[2]);
   __pyx_v_df = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[3]);
 
-  /* "beam_calc.pyx":30
+  /* "beam_calc.pyx":38
  *         float_t x = (<float_t*> params)[0], wl = (<float_t*> params)[1]
  *         float_t f = (<float_t*> params)[2], df = (<float_t*> params)[3]
- *         float_t a = (<float_t*> params)[4]             # <<<<<<<<<<<<<<
+ *         float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]             # <<<<<<<<<<<<<<
  *         float_t ph, ph_ab
  *     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx
  */
   __pyx_v_a = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[4]);
+  __pyx_v_x0 = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[5]);
 
-  /* "beam_calc.pyx":32
- *         float_t a = (<float_t*> params)[4]
+  /* "beam_calc.pyx":40
+ *         float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]
  *         float_t ph, ph_ab
  *     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx             # <<<<<<<<<<<<<<
- *     ph_ab = -a * 1e9 * (xx / f)**3
+ *     ph_ab = -a * 1e9 * ((xx - x0) / f)**3
  *     return sin(ph + ph_ab)
  */
   __pyx_v_ph = (((((((-M_PI) * pow(__pyx_v_xx, 2.0)) / __pyx_v_wl) * __pyx_v_df) / __pyx_v_f) / (__pyx_v_f + __pyx_v_df)) - ((((((__pyx_t_9beam_calc_float_t)(2.0 * M_PI)) / __pyx_v_wl) / (__pyx_v_f + __pyx_v_df)) * __pyx_v_x) * __pyx_v_xx));
 
-  /* "beam_calc.pyx":33
+  /* "beam_calc.pyx":41
  *         float_t ph, ph_ab
  *     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx
- *     ph_ab = -a * 1e9 * (xx / f)**3             # <<<<<<<<<<<<<<
+ *     ph_ab = -a * 1e9 * ((xx - x0) / f)**3             # <<<<<<<<<<<<<<
  *     return sin(ph + ph_ab)
  * 
  */
-  __pyx_v_ph_ab = (((-__pyx_v_a) * 1e9) * pow((__pyx_v_xx / __pyx_v_f), 3.0));
+  __pyx_v_ph_ab = (((-__pyx_v_a) * 1e9) * pow(((__pyx_v_xx - __pyx_v_x0) / __pyx_v_f), 3.0));
 
-  /* "beam_calc.pyx":34
+  /* "beam_calc.pyx":42
  *     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx
- *     ph_ab = -a * 1e9 * (xx / f)**3
+ *     ph_ab = -a * 1e9 * ((xx - x0) / f)**3
  *     return sin(ph + ph_ab)             # <<<<<<<<<<<<<<
  * 
- * cdef float_t aperture_re(float_t xx, void* params) nogil:
+ * cdef complex_t lens_wp(float_t x, float_t wl, float_t ap, float_t f,
  */
   __pyx_r = sin((__pyx_v_ph + __pyx_v_ph_ab));
   goto __pyx_L0;
 
-  /* "beam_calc.pyx":26
+  /* "beam_calc.pyx":34
  *     return cos(ph + ph_ab)
  * 
  * cdef float_t lens_im(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
@@ -3304,47 +3385,122 @@ static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_lens_im(__pyx_t_9beam_calc_
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":36
+/* "beam_calc.pyx":44
  *     return sin(ph + ph_ab)
  * 
- * cdef float_t aperture_re(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
+ * cdef complex_t lens_wp(float_t x, float_t wl, float_t ap, float_t f,             # <<<<<<<<<<<<<<
+ *                        float_t df, float_t a, float_t x0) nogil:
  *     cdef:
- *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
  */
 
-static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_aperture_re(__pyx_t_9beam_calc_float_t __pyx_v_xx, void *__pyx_v_params) {
-  __pyx_t_9beam_calc_float_t __pyx_v_x;
-  __pyx_t_9beam_calc_float_t __pyx_v_z;
-  __pyx_t_9beam_calc_float_t __pyx_v_wl;
-  __pyx_t_9beam_calc_float_t __pyx_r;
+static __pyx_t_double_complex __pyx_f_9beam_calc_lens_wp(__pyx_t_9beam_calc_float_t __pyx_v_x, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap, __pyx_t_9beam_calc_float_t __pyx_v_f, __pyx_t_9beam_calc_float_t __pyx_v_df, __pyx_t_9beam_calc_float_t __pyx_v_a, __pyx_t_9beam_calc_float_t __pyx_v_x0) {
+  __pyx_t_9beam_calc_float_t __pyx_v_re;
+  __pyx_t_9beam_calc_float_t __pyx_v_im;
+  __pyx_t_9beam_calc_float_t __pyx_v_ph;
+  __pyx_t_9beam_calc_float_t __pyx_v_params[6];
+  __pyx_t_9beam_calc_int_t __pyx_v_fn;
+  gsl_function __pyx_v_func;
+  __pyx_t_double_complex __pyx_r;
+  __pyx_t_double_complex __pyx_t_1;
+  __pyx_t_double_complex __pyx_t_2;
+  __pyx_t_npy_float64_complex __pyx_t_3;
 
-  /* "beam_calc.pyx":38
- * cdef float_t aperture_re(float_t xx, void* params) nogil:
+  /* "beam_calc.pyx":47
+ *                        float_t df, float_t a, float_t x0) nogil:
  *     cdef:
- *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]             # <<<<<<<<<<<<<<
- *     return cos(pi / wl / z * (x - xx)**2)
+ *         float_t re, im, ph = pi / wl / (f + df) * x**2             # <<<<<<<<<<<<<<
+ *         float_t params[6]
+ *         int_t fn = <int_t> (ap**2 / wl / (f + df))
+ */
+  __pyx_v_ph = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / (__pyx_v_f + __pyx_v_df)) * pow(__pyx_v_x, 2.0));
+
+  /* "beam_calc.pyx":49
+ *         float_t re, im, ph = pi / wl / (f + df) * x**2
+ *         float_t params[6]
+ *         int_t fn = <int_t> (ap**2 / wl / (f + df))             # <<<<<<<<<<<<<<
+ *         gsl_function func
+ *     params[0] = x; params[1] = wl; params[2] = f
+ */
+  __pyx_v_fn = ((__pyx_t_9beam_calc_int_t)((pow(__pyx_v_ap, 2.0) / __pyx_v_wl) / (__pyx_v_f + __pyx_v_df)));
+
+  /* "beam_calc.pyx":51
+ *         int_t fn = <int_t> (ap**2 / wl / (f + df))
+ *         gsl_function func
+ *     params[0] = x; params[1] = wl; params[2] = f             # <<<<<<<<<<<<<<
+ *     params[3] = df; params[4] = a; params[5] = x0
+ *     func.function = &lens_re; func.params = params
+ */
+  (__pyx_v_params[0]) = __pyx_v_x;
+  (__pyx_v_params[1]) = __pyx_v_wl;
+  (__pyx_v_params[2]) = __pyx_v_f;
+
+  /* "beam_calc.pyx":52
+ *         gsl_function func
+ *     params[0] = x; params[1] = wl; params[2] = f
+ *     params[3] = df; params[4] = a; params[5] = x0             # <<<<<<<<<<<<<<
+ *     func.function = &lens_re; func.params = params
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ */
+  (__pyx_v_params[3]) = __pyx_v_df;
+  (__pyx_v_params[4]) = __pyx_v_a;
+  (__pyx_v_params[5]) = __pyx_v_x0;
+
+  /* "beam_calc.pyx":53
+ *     params[0] = x; params[1] = wl; params[2] = f
+ *     params[3] = df; params[4] = a; params[5] = x0
+ *     func.function = &lens_re; func.params = params             # <<<<<<<<<<<<<<
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     func.function = &lens_im
+ */
+  __pyx_v_func.function = (&__pyx_f_9beam_calc_lens_re);
+  __pyx_v_func.params = __pyx_v_params;
+
+  /* "beam_calc.pyx":54
+ *     params[3] = df; params[4] = a; params[5] = x0
+ *     func.function = &lens_re; func.params = params
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)             # <<<<<<<<<<<<<<
+ *     func.function = &lens_im
+ *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ */
+  __pyx_v_re = __pyx_f_9beam_calc_gsl_quad(__pyx_v_func, ((-__pyx_v_ap) / 2.0), (__pyx_v_ap / 2.0), 1e-9, 1e-7, (0x3E8 * __pyx_v_fn));
+
+  /* "beam_calc.pyx":55
+ *     func.function = &lens_re; func.params = params
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     func.function = &lens_im             # <<<<<<<<<<<<<<
+ *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     return (re + 1j * im) * (cos(ph) + 1j * sin(ph))
+ */
+  __pyx_v_func.function = (&__pyx_f_9beam_calc_lens_im);
+
+  /* "beam_calc.pyx":56
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     func.function = &lens_im
+ *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)             # <<<<<<<<<<<<<<
+ *     return (re + 1j * im) * (cos(ph) + 1j * sin(ph))
  * 
  */
-  __pyx_v_x = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[0]);
-  __pyx_v_z = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[1]);
-  __pyx_v_wl = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[2]);
+  __pyx_v_im = __pyx_f_9beam_calc_gsl_quad(__pyx_v_func, ((-__pyx_v_ap) / 2.0), (__pyx_v_ap / 2.0), 1e-9, 1e-7, (0x3E8 * __pyx_v_fn));
 
-  /* "beam_calc.pyx":39
- *     cdef:
- *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
- *     return cos(pi / wl / z * (x - xx)**2)             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":57
+ *     func.function = &lens_im
+ *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     return (re + 1j * im) * (cos(ph) + 1j * sin(ph))             # <<<<<<<<<<<<<<
+ * 
  * 
- * cdef float_t aperture_im(float_t xx, void* params) nogil:
  */
-  __pyx_r = cos((((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_z) * pow((__pyx_v_x - __pyx_v_xx), 2.0)));
+  __pyx_t_1 = __pyx_t_double_complex_from_parts(0, 1.0);
+  __pyx_t_2 = __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph), 0)));
+  __pyx_t_3 = __Pyx_c_prod_npy_float64(__Pyx_c_sum_npy_float64(__pyx_t_npy_float64_complex_from_parts(__pyx_v_re, 0), __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_1), __Pyx_CIMAG(__pyx_t_1)), __pyx_t_npy_float64_complex_from_parts(__pyx_v_im, 0))), __pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_2), __Pyx_CIMAG(__pyx_t_2)));
+  __pyx_r = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_3), __Pyx_CIMAG(__pyx_t_3));
   goto __pyx_L0;
 
-  /* "beam_calc.pyx":36
+  /* "beam_calc.pyx":44
  *     return sin(ph + ph_ab)
  * 
- * cdef float_t aperture_re(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
+ * cdef complex_t lens_wp(float_t x, float_t wl, float_t ap, float_t f,             # <<<<<<<<<<<<<<
+ *                        float_t df, float_t a, float_t x0) nogil:
  *     cdef:
- *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
  */
 
   /* function exit code */
@@ -3352,1733 +3508,43 @@ static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_aperture_re(__pyx_t_9beam_c
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":41
- *     return cos(pi / wl / z * (x - xx)**2)
+/* "beam_calc.pyx":60
  * 
- * cdef float_t aperture_im(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
+ * 
+ * def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,             # <<<<<<<<<<<<<<
+ *          float_t defoc, float_t alpha, float_t x0):
+ *     """
  */
 
-static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_aperture_im(__pyx_t_9beam_calc_float_t __pyx_v_xx, void *__pyx_v_params) {
-  __pyx_t_9beam_calc_float_t __pyx_v_x;
-  __pyx_t_9beam_calc_float_t __pyx_v_z;
-  __pyx_t_9beam_calc_float_t __pyx_v_wl;
-  __pyx_t_9beam_calc_float_t __pyx_r;
-
-  /* "beam_calc.pyx":43
- * cdef float_t aperture_im(float_t xx, void* params) nogil:
- *     cdef:
- *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]             # <<<<<<<<<<<<<<
- *     return sin(pi / wl / z * (x - xx)**2)
- * 
- */
-  __pyx_v_x = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[0]);
-  __pyx_v_z = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[1]);
-  __pyx_v_wl = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[2]);
-
-  /* "beam_calc.pyx":44
- *     cdef:
- *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
- *     return sin(pi / wl / z * (x - xx)**2)             # <<<<<<<<<<<<<<
- * 
- * cdef float_t gsl_quad(gsl_function func, float_t a, float_t b, float_t eps_abs, float_t eps_rel, int_t limit) nogil:
- */
-  __pyx_r = sin((((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_z) * pow((__pyx_v_x - __pyx_v_xx), 2.0)));
-  goto __pyx_L0;
-
-  /* "beam_calc.pyx":41
- *     return cos(pi / wl / z * (x - xx)**2)
- * 
- * cdef float_t aperture_im(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "beam_calc.pyx":46
- *     return sin(pi / wl / z * (x - xx)**2)
- * 
- * cdef float_t gsl_quad(gsl_function func, float_t a, float_t b, float_t eps_abs, float_t eps_rel, int_t limit) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         float_t result, error
- */
-
-static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_gsl_quad(gsl_function __pyx_v_func, __pyx_t_9beam_calc_float_t __pyx_v_a, __pyx_t_9beam_calc_float_t __pyx_v_b, __pyx_t_9beam_calc_float_t __pyx_v_eps_abs, __pyx_t_9beam_calc_float_t __pyx_v_eps_rel, __pyx_t_9beam_calc_int_t __pyx_v_limit) {
-  __pyx_t_9beam_calc_float_t __pyx_v_result;
-  __pyx_t_9beam_calc_float_t __pyx_v_error;
-  gsl_integration_workspace *__pyx_v_W;
-  __pyx_t_9beam_calc_float_t __pyx_r;
-
-  /* "beam_calc.pyx":50
- *         float_t result, error
- *         gsl_integration_workspace * W
- *     W = gsl_integration_workspace_alloc(limit)             # <<<<<<<<<<<<<<
- *     gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)
- *     gsl_integration_workspace_free(W)
- */
-  __pyx_v_W = gsl_integration_workspace_alloc(__pyx_v_limit);
-
-  /* "beam_calc.pyx":51
- *         gsl_integration_workspace * W
- *     W = gsl_integration_workspace_alloc(limit)
- *     gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)             # <<<<<<<<<<<<<<
- *     gsl_integration_workspace_free(W)
- *     return result
- */
-  (void)(gsl_integration_qag((&__pyx_v_func), __pyx_v_a, __pyx_v_b, __pyx_v_eps_abs, __pyx_v_eps_rel, __pyx_v_limit, GSL_INTEG_GAUSS51, __pyx_v_W, (&__pyx_v_result), (&__pyx_v_error)));
-
-  /* "beam_calc.pyx":52
- *     W = gsl_integration_workspace_alloc(limit)
- *     gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)
- *     gsl_integration_workspace_free(W)             # <<<<<<<<<<<<<<
- *     return result
- * 
- */
-  gsl_integration_workspace_free(__pyx_v_W);
-
-  /* "beam_calc.pyx":53
- *     gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)
- *     gsl_integration_workspace_free(W)
- *     return result             # <<<<<<<<<<<<<<
- * 
- * cdef complex_t lens_wp(float_t x, float_t wl, float_t ap, float_t f, float_t df, float_t a) nogil:
- */
-  __pyx_r = __pyx_v_result;
-  goto __pyx_L0;
-
-  /* "beam_calc.pyx":46
- *     return sin(pi / wl / z * (x - xx)**2)
- * 
- * cdef float_t gsl_quad(gsl_function func, float_t a, float_t b, float_t eps_abs, float_t eps_rel, int_t limit) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         float_t result, error
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "beam_calc.pyx":55
- *     return result
- * 
- * cdef complex_t lens_wp(float_t x, float_t wl, float_t ap, float_t f, float_t df, float_t a) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         float_t re, im, ph = pi / wl / (f + df) * x**2
- */
-
-static __pyx_t_double_complex __pyx_f_9beam_calc_lens_wp(__pyx_t_9beam_calc_float_t __pyx_v_x, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap, __pyx_t_9beam_calc_float_t __pyx_v_f, __pyx_t_9beam_calc_float_t __pyx_v_df, __pyx_t_9beam_calc_float_t __pyx_v_a) {
-  __pyx_t_9beam_calc_float_t __pyx_v_re;
-  __pyx_t_9beam_calc_float_t __pyx_v_im;
-  __pyx_t_9beam_calc_float_t __pyx_v_ph;
-  __pyx_t_9beam_calc_float_t __pyx_v_params[5];
-  __pyx_t_9beam_calc_int_t __pyx_v_fn;
-  gsl_function __pyx_v_func;
-  __pyx_t_double_complex __pyx_r;
-  __pyx_t_double_complex __pyx_t_1;
-  __pyx_t_double_complex __pyx_t_2;
-  __pyx_t_npy_float64_complex __pyx_t_3;
-
-  /* "beam_calc.pyx":57
- * cdef complex_t lens_wp(float_t x, float_t wl, float_t ap, float_t f, float_t df, float_t a) nogil:
- *     cdef:
- *         float_t re, im, ph = pi / wl / (f + df) * x**2             # <<<<<<<<<<<<<<
- *         float_t params[5]
- *         int_t fn = <int_t> (ap**2 / wl / (f + df))
- */
-  __pyx_v_ph = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / (__pyx_v_f + __pyx_v_df)) * pow(__pyx_v_x, 2.0));
-
-  /* "beam_calc.pyx":59
- *         float_t re, im, ph = pi / wl / (f + df) * x**2
- *         float_t params[5]
- *         int_t fn = <int_t> (ap**2 / wl / (f + df))             # <<<<<<<<<<<<<<
- *         gsl_function func
- *     params[0] = x; params[1] = wl; params[2] = f
- */
-  __pyx_v_fn = ((__pyx_t_9beam_calc_int_t)((pow(__pyx_v_ap, 2.0) / __pyx_v_wl) / (__pyx_v_f + __pyx_v_df)));
-
-  /* "beam_calc.pyx":61
- *         int_t fn = <int_t> (ap**2 / wl / (f + df))
- *         gsl_function func
- *     params[0] = x; params[1] = wl; params[2] = f             # <<<<<<<<<<<<<<
- *     params[3] = df; params[4] = a
- *     func.function = &lens_re; func.params = params
- */
-  (__pyx_v_params[0]) = __pyx_v_x;
-  (__pyx_v_params[1]) = __pyx_v_wl;
-  (__pyx_v_params[2]) = __pyx_v_f;
-
-  /* "beam_calc.pyx":62
- *         gsl_function func
- *     params[0] = x; params[1] = wl; params[2] = f
- *     params[3] = df; params[4] = a             # <<<<<<<<<<<<<<
- *     func.function = &lens_re; func.params = params
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- */
-  (__pyx_v_params[3]) = __pyx_v_df;
-  (__pyx_v_params[4]) = __pyx_v_a;
-
-  /* "beam_calc.pyx":63
- *     params[0] = x; params[1] = wl; params[2] = f
- *     params[3] = df; params[4] = a
- *     func.function = &lens_re; func.params = params             # <<<<<<<<<<<<<<
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     func.function = &lens_im
- */
-  __pyx_v_func.function = (&__pyx_f_9beam_calc_lens_re);
-  __pyx_v_func.params = __pyx_v_params;
-
-  /* "beam_calc.pyx":64
- *     params[3] = df; params[4] = a
- *     func.function = &lens_re; func.params = params
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)             # <<<<<<<<<<<<<<
- *     func.function = &lens_im
- *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- */
-  __pyx_v_re = __pyx_f_9beam_calc_gsl_quad(__pyx_v_func, ((-__pyx_v_ap) / 2.0), (__pyx_v_ap / 2.0), 1e-9, 1e-7, (0x3E8 * __pyx_v_fn));
-
-  /* "beam_calc.pyx":65
- *     func.function = &lens_re; func.params = params
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     func.function = &lens_im             # <<<<<<<<<<<<<<
- *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     return (re + 1j * im) * (cos(ph) + 1j * sin(ph))
- */
-  __pyx_v_func.function = (&__pyx_f_9beam_calc_lens_im);
-
-  /* "beam_calc.pyx":66
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     func.function = &lens_im
- *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)             # <<<<<<<<<<<<<<
- *     return (re + 1j * im) * (cos(ph) + 1j * sin(ph))
- * 
- */
-  __pyx_v_im = __pyx_f_9beam_calc_gsl_quad(__pyx_v_func, ((-__pyx_v_ap) / 2.0), (__pyx_v_ap / 2.0), 1e-9, 1e-7, (0x3E8 * __pyx_v_fn));
-
-  /* "beam_calc.pyx":67
- *     func.function = &lens_im
- *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     return (re + 1j * im) * (cos(ph) + 1j * sin(ph))             # <<<<<<<<<<<<<<
- * 
- * cdef complex_t aperture_wp(float_t x, float_t z, float_t wl, float_t ap) nogil:
- */
-  __pyx_t_1 = __pyx_t_double_complex_from_parts(0, 1.0);
-  __pyx_t_2 = __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph), 0)));
-  __pyx_t_3 = __Pyx_c_prod_npy_float64(__Pyx_c_sum_npy_float64(__pyx_t_npy_float64_complex_from_parts(__pyx_v_re, 0), __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_1), __Pyx_CIMAG(__pyx_t_1)), __pyx_t_npy_float64_complex_from_parts(__pyx_v_im, 0))), __pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_2), __Pyx_CIMAG(__pyx_t_2)));
-  __pyx_r = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_3), __Pyx_CIMAG(__pyx_t_3));
-  goto __pyx_L0;
-
-  /* "beam_calc.pyx":55
- *     return result
- * 
- * cdef complex_t lens_wp(float_t x, float_t wl, float_t ap, float_t f, float_t df, float_t a) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         float_t re, im, ph = pi / wl / (f + df) * x**2
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "beam_calc.pyx":69
- *     return (re + 1j * im) * (cos(ph) + 1j * sin(ph))
- * 
- * cdef complex_t aperture_wp(float_t x, float_t z, float_t wl, float_t ap) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         float_t re, im
- */
-
-static __pyx_t_double_complex __pyx_f_9beam_calc_aperture_wp(__pyx_t_9beam_calc_float_t __pyx_v_x, __pyx_t_9beam_calc_float_t __pyx_v_z, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap) {
-  __pyx_t_9beam_calc_float_t __pyx_v_re;
-  __pyx_t_9beam_calc_float_t __pyx_v_im;
-  __pyx_t_9beam_calc_float_t __pyx_v_params[3];
-  __pyx_t_9beam_calc_int_t __pyx_v_fn;
-  gsl_function __pyx_v_func;
-  __pyx_t_double_complex __pyx_r;
-  __pyx_t_double_complex __pyx_t_1;
-  __pyx_t_npy_float64_complex __pyx_t_2;
-
-  /* "beam_calc.pyx":73
- *         float_t re, im
- *         float_t params[3]
- *         int_t fn = <int_t> (ap**2 / wl / z)             # <<<<<<<<<<<<<<
- *         gsl_function func
- *     params[0] = x; params[1] = z; params[2] = wl
- */
-  __pyx_v_fn = ((__pyx_t_9beam_calc_int_t)((pow(__pyx_v_ap, 2.0) / __pyx_v_wl) / __pyx_v_z));
-
-  /* "beam_calc.pyx":75
- *         int_t fn = <int_t> (ap**2 / wl / z)
- *         gsl_function func
- *     params[0] = x; params[1] = z; params[2] = wl             # <<<<<<<<<<<<<<
- *     func.function = &aperture_re; func.params = params
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- */
-  (__pyx_v_params[0]) = __pyx_v_x;
-  (__pyx_v_params[1]) = __pyx_v_z;
-  (__pyx_v_params[2]) = __pyx_v_wl;
-
-  /* "beam_calc.pyx":76
- *         gsl_function func
- *     params[0] = x; params[1] = z; params[2] = wl
- *     func.function = &aperture_re; func.params = params             # <<<<<<<<<<<<<<
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     func.function = &aperture_im
- */
-  __pyx_v_func.function = (&__pyx_f_9beam_calc_aperture_re);
-  __pyx_v_func.params = __pyx_v_params;
-
-  /* "beam_calc.pyx":77
- *     params[0] = x; params[1] = z; params[2] = wl
- *     func.function = &aperture_re; func.params = params
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)             # <<<<<<<<<<<<<<
- *     func.function = &aperture_im
- *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- */
-  __pyx_v_re = __pyx_f_9beam_calc_gsl_quad(__pyx_v_func, ((-__pyx_v_ap) / 2.0), (__pyx_v_ap / 2.0), 1e-9, 1e-7, (0x3E8 * __pyx_v_fn));
-
-  /* "beam_calc.pyx":78
- *     func.function = &aperture_re; func.params = params
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     func.function = &aperture_im             # <<<<<<<<<<<<<<
- *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     return re + 1j * im
- */
-  __pyx_v_func.function = (&__pyx_f_9beam_calc_aperture_im);
-
-  /* "beam_calc.pyx":79
- *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     func.function = &aperture_im
- *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)             # <<<<<<<<<<<<<<
- *     return re + 1j * im
- * 
- */
-  __pyx_v_im = __pyx_f_9beam_calc_gsl_quad(__pyx_v_func, ((-__pyx_v_ap) / 2.0), (__pyx_v_ap / 2.0), 1e-9, 1e-7, (0x3E8 * __pyx_v_fn));
-
-  /* "beam_calc.pyx":80
- *     func.function = &aperture_im
- *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
- *     return re + 1j * im             # <<<<<<<<<<<<<<
- * 
- * cdef complex_t fhf_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
- */
-  __pyx_t_1 = __pyx_t_double_complex_from_parts(0, 1.0);
-  __pyx_t_2 = __Pyx_c_sum_npy_float64(__pyx_t_npy_float64_complex_from_parts(__pyx_v_re, 0), __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_1), __Pyx_CIMAG(__pyx_t_1)), __pyx_t_npy_float64_complex_from_parts(__pyx_v_im, 0)));
-  __pyx_r = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_2), __Pyx_CIMAG(__pyx_t_2));
-  goto __pyx_L0;
-
-  /* "beam_calc.pyx":69
- *     return (re + 1j * im) * (cos(ph) + 1j * sin(ph))
- * 
- * cdef complex_t aperture_wp(float_t x, float_t z, float_t wl, float_t ap) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         float_t re, im
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "beam_calc.pyx":82
- *     return re + 1j * im
- * 
- * cdef complex_t fhf_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = wf0.shape[0], i
- */
-
-static __pyx_t_double_complex __pyx_f_9beam_calc_fhf_wp(__Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_xx, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
-  __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __pyx_t_9beam_calc_float_t __pyx_v_ph0;
-  __pyx_t_9beam_calc_float_t __pyx_v_ph1;
-  __pyx_t_9beam_calc_float_t __pyx_v_ph;
-  __pyx_t_double_complex __pyx_v_wf;
-  __pyx_t_double_complex __pyx_r;
-  Py_ssize_t __pyx_t_1;
-  Py_ssize_t __pyx_t_2;
-  Py_ssize_t __pyx_t_3;
-  Py_ssize_t __pyx_t_4;
-  __pyx_t_double_complex __pyx_t_5;
-  Py_ssize_t __pyx_t_6;
-  Py_ssize_t __pyx_t_7;
-  __pyx_t_npy_float64_complex __pyx_t_8;
-  __pyx_t_9beam_calc_int_t __pyx_t_9;
-  __pyx_t_9beam_calc_int_t __pyx_t_10;
-  __pyx_t_9beam_calc_int_t __pyx_t_11;
-  __pyx_t_9beam_calc_int_t __pyx_t_12;
-  __pyx_t_9beam_calc_int_t __pyx_t_13;
-  __pyx_t_9beam_calc_int_t __pyx_t_14;
-  __pyx_t_9beam_calc_int_t __pyx_t_15;
-  __pyx_t_9beam_calc_int_t __pyx_t_16;
-
-  /* "beam_calc.pyx":84
- * cdef complex_t fhf_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
- *     cdef:
- *         int_t a = wf0.shape[0], i             # <<<<<<<<<<<<<<
- *         float_t ph0, ph1, ph = pi / wl / dist * xx**2
- *         complex_t wf = 0 + 0j
- */
-  __pyx_v_a = (__pyx_v_wf0.shape[0]);
-
-  /* "beam_calc.pyx":85
- *     cdef:
- *         int_t a = wf0.shape[0], i
- *         float_t ph0, ph1, ph = pi / wl / dist * xx**2             # <<<<<<<<<<<<<<
- *         complex_t wf = 0 + 0j
- *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx
- */
-  __pyx_v_ph = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_dist) * pow(__pyx_v_xx, 2.0));
-
-  /* "beam_calc.pyx":86
- *         int_t a = wf0.shape[0], i
- *         float_t ph0, ph1, ph = pi / wl / dist * xx**2
- *         complex_t wf = 0 + 0j             # <<<<<<<<<<<<<<
- *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx
- *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx
- */
-  __pyx_v_wf = __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(0, 0), __pyx_t_double_complex_from_parts(0, 0.0));
-
-  /* "beam_calc.pyx":87
- *         float_t ph0, ph1, ph = pi / wl / dist * xx**2
- *         complex_t wf = 0 + 0j
- *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx             # <<<<<<<<<<<<<<
- *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx
- *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
- */
-  __pyx_t_1 = 0;
-  __pyx_v_ph0 = ((((((__pyx_t_9beam_calc_float_t)(2.0 * M_PI)) / __pyx_v_wl) / __pyx_v_dist) * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_1)) )))) * __pyx_v_xx);
-
-  /* "beam_calc.pyx":88
- *         complex_t wf = 0 + 0j
- *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx
- *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx             # <<<<<<<<<<<<<<
- *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
- *     for i in range(2, a):
- */
-  __pyx_t_2 = 1;
-  __pyx_v_ph1 = ((((((__pyx_t_9beam_calc_float_t)(2.0 * M_PI)) / __pyx_v_wl) / __pyx_v_dist) * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_2)) )))) * __pyx_v_xx);
-
-  /* "beam_calc.pyx":89
- *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx
- *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx
- *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])             # <<<<<<<<<<<<<<
- *     for i in range(2, a):
- *         ph0 = ph1
- */
-  __pyx_t_3 = 0;
-  __pyx_t_4 = 1;
-  __pyx_t_5 = __Pyx_c_quot_double(__Pyx_c_sum_double(__Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_3)) ))), __Pyx_c_diff_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph0), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph0), 0)))), __Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_4)) ))), __Pyx_c_diff_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph1), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph1), 0))))), __pyx_t_double_complex_from_parts(2, 0));
-  __pyx_t_6 = 1;
-  __pyx_t_7 = 0;
-  __pyx_t_8 = __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_5), __Pyx_CIMAG(__pyx_t_5)), __pyx_t_npy_float64_complex_from_parts(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_6)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_7)) )))), 0));
-  __pyx_v_wf = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_8), __Pyx_CIMAG(__pyx_t_8));
-
-  /* "beam_calc.pyx":90
- *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx
- *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
- *     for i in range(2, a):             # <<<<<<<<<<<<<<
- *         ph0 = ph1
- *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx
- */
-  __pyx_t_9 = __pyx_v_a;
-  __pyx_t_10 = __pyx_t_9;
-  for (__pyx_t_11 = 2; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
-    __pyx_v_i = __pyx_t_11;
-
-    /* "beam_calc.pyx":91
- *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
- *     for i in range(2, a):
- *         ph0 = ph1             # <<<<<<<<<<<<<<
- *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx
- *         wf += (wf0[i - 1] * (cos(ph0) - 1j * sin(ph0)) + wf0[i] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
- */
-    __pyx_v_ph0 = __pyx_v_ph1;
-
-    /* "beam_calc.pyx":92
- *     for i in range(2, a):
- *         ph0 = ph1
- *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx             # <<<<<<<<<<<<<<
- *         wf += (wf0[i - 1] * (cos(ph0) - 1j * sin(ph0)) + wf0[i] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
- *     return wf * (cos(ph) + 1j * sin(ph))
- */
-    __pyx_t_12 = __pyx_v_i;
-    __pyx_v_ph1 = ((((((__pyx_t_9beam_calc_float_t)(2.0 * M_PI)) / __pyx_v_wl) / __pyx_v_dist) * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_12)) )))) * __pyx_v_xx);
-
-    /* "beam_calc.pyx":93
- *         ph0 = ph1
- *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx
- *         wf += (wf0[i - 1] * (cos(ph0) - 1j * sin(ph0)) + wf0[i] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])             # <<<<<<<<<<<<<<
- *     return wf * (cos(ph) + 1j * sin(ph))
- * 
- */
-    __pyx_t_13 = (__pyx_v_i - 1);
-    __pyx_t_14 = __pyx_v_i;
-    __pyx_t_5 = __Pyx_c_quot_double(__Pyx_c_sum_double(__Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_13)) ))), __Pyx_c_diff_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph0), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph0), 0)))), __Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_14)) ))), __Pyx_c_diff_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph1), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph1), 0))))), __pyx_t_double_complex_from_parts(2, 0));
-    __pyx_t_15 = __pyx_v_i;
-    __pyx_t_16 = (__pyx_v_i - 1);
-    __pyx_t_8 = __Pyx_c_sum_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_v_wf), __Pyx_CIMAG(__pyx_v_wf)), __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_5), __Pyx_CIMAG(__pyx_t_5)), __pyx_t_npy_float64_complex_from_parts(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_15)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_16)) )))), 0)));
-    __pyx_v_wf = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_8), __Pyx_CIMAG(__pyx_t_8));
-  }
-
-  /* "beam_calc.pyx":94
- *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx
- *         wf += (wf0[i - 1] * (cos(ph0) - 1j * sin(ph0)) + wf0[i] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
- *     return wf * (cos(ph) + 1j * sin(ph))             # <<<<<<<<<<<<<<
- * 
- * cdef void fhf_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
- */
-  __pyx_r = __Pyx_c_prod_double(__pyx_v_wf, __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph), 0))));
-  goto __pyx_L0;
-
-  /* "beam_calc.pyx":82
- *     return re + 1j * im
- * 
- * cdef complex_t fhf_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = wf0.shape[0], i
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "beam_calc.pyx":96
- *     return wf * (cos(ph) + 1j * sin(ph))
- * 
- * cdef void fhf_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = xx_arr.shape[0], i
- */
-
-static void __pyx_f_9beam_calc_fhf_1d(__Pyx_memviewslice __pyx_v_wf1, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
-  __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __pyx_t_9beam_calc_int_t __pyx_t_1;
-  __pyx_t_9beam_calc_int_t __pyx_t_2;
-  __pyx_t_9beam_calc_int_t __pyx_t_3;
-  __pyx_t_9beam_calc_int_t __pyx_t_4;
-  __pyx_t_9beam_calc_int_t __pyx_t_5;
-
-  /* "beam_calc.pyx":98
- * cdef void fhf_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
- *     cdef:
- *         int_t a = xx_arr.shape[0], i             # <<<<<<<<<<<<<<
- *     for i in range(a):
- *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
- */
-  __pyx_v_a = (__pyx_v_xx_arr.shape[0]);
-
-  /* "beam_calc.pyx":99
- *     cdef:
- *         int_t a = xx_arr.shape[0], i
- *     for i in range(a):             # <<<<<<<<<<<<<<
- *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
- * 
- */
-  __pyx_t_1 = __pyx_v_a;
-  __pyx_t_2 = __pyx_t_1;
-  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
-    __pyx_v_i = __pyx_t_3;
-
-    /* "beam_calc.pyx":100
- *         int_t a = xx_arr.shape[0], i
- *     for i in range(a):
- *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)             # <<<<<<<<<<<<<<
- * 
- * cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
- */
-    __pyx_t_4 = __pyx_v_i;
-    __pyx_t_5 = __pyx_v_i;
-    *((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf1.data) + __pyx_t_5)) )) = __pyx_f_9beam_calc_fhf_wp(__pyx_v_wf0, __pyx_v_x_arr, (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_xx_arr.data) + __pyx_t_4)) ))), __pyx_v_dist, __pyx_v_wl);
-  }
-
-  /* "beam_calc.pyx":96
- *     return wf * (cos(ph) + 1j * sin(ph))
- * 
- * cdef void fhf_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = xx_arr.shape[0], i
- */
-
-  /* function exit code */
-}
-
-/* "beam_calc.pyx":102
- *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
- * 
- * cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = wf0.shape[0], i
- */
-
-static __pyx_t_double_complex __pyx_f_9beam_calc_fnl_wp(__Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_xx, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
-  __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __pyx_t_9beam_calc_float_t __pyx_v_ph0;
-  __pyx_t_9beam_calc_float_t __pyx_v_ph1;
-  __pyx_t_double_complex __pyx_v_wf;
-  __pyx_t_double_complex __pyx_r;
-  Py_ssize_t __pyx_t_1;
-  Py_ssize_t __pyx_t_2;
-  Py_ssize_t __pyx_t_3;
-  Py_ssize_t __pyx_t_4;
-  __pyx_t_double_complex __pyx_t_5;
-  Py_ssize_t __pyx_t_6;
-  Py_ssize_t __pyx_t_7;
-  __pyx_t_npy_float64_complex __pyx_t_8;
-  __pyx_t_9beam_calc_int_t __pyx_t_9;
-  __pyx_t_9beam_calc_int_t __pyx_t_10;
-  __pyx_t_9beam_calc_int_t __pyx_t_11;
-  __pyx_t_9beam_calc_int_t __pyx_t_12;
-  __pyx_t_9beam_calc_int_t __pyx_t_13;
-  __pyx_t_9beam_calc_int_t __pyx_t_14;
-  __pyx_t_9beam_calc_int_t __pyx_t_15;
-  __pyx_t_9beam_calc_int_t __pyx_t_16;
-
-  /* "beam_calc.pyx":104
- * cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
- *     cdef:
- *         int_t a = wf0.shape[0], i             # <<<<<<<<<<<<<<
- *         float_t ph0, ph1
- *         complex_t wf
- */
-  __pyx_v_a = (__pyx_v_wf0.shape[0]);
-
-  /* "beam_calc.pyx":107
- *         float_t ph0, ph1
- *         complex_t wf
- *     ph0 = pi / wl / dist * (x_arr[0] - xx)**2             # <<<<<<<<<<<<<<
- *     ph1 = pi / wl / dist * (x_arr[1] - xx)**2
- *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
- */
-  __pyx_t_1 = 0;
-  __pyx_v_ph0 = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_dist) * pow(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_1)) ))) - __pyx_v_xx), 2.0));
-
-  /* "beam_calc.pyx":108
- *         complex_t wf
- *     ph0 = pi / wl / dist * (x_arr[0] - xx)**2
- *     ph1 = pi / wl / dist * (x_arr[1] - xx)**2             # <<<<<<<<<<<<<<
- *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
- *     for i in range(2, a):
- */
-  __pyx_t_2 = 1;
-  __pyx_v_ph1 = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_dist) * pow(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_2)) ))) - __pyx_v_xx), 2.0));
-
-  /* "beam_calc.pyx":109
- *     ph0 = pi / wl / dist * (x_arr[0] - xx)**2
- *     ph1 = pi / wl / dist * (x_arr[1] - xx)**2
- *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])             # <<<<<<<<<<<<<<
- *     for i in range(2, a):
- *         ph0 = ph1
- */
-  __pyx_t_3 = 0;
-  __pyx_t_4 = 1;
-  __pyx_t_5 = __Pyx_c_quot_double(__Pyx_c_sum_double(__Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_3)) ))), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph0), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph0), 0)))), __Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_4)) ))), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph1), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph1), 0))))), __pyx_t_double_complex_from_parts(2, 0));
-  __pyx_t_6 = 1;
-  __pyx_t_7 = 0;
-  __pyx_t_8 = __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_5), __Pyx_CIMAG(__pyx_t_5)), __pyx_t_npy_float64_complex_from_parts(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_6)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_7)) )))), 0));
-  __pyx_v_wf = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_8), __Pyx_CIMAG(__pyx_t_8));
-
-  /* "beam_calc.pyx":110
- *     ph1 = pi / wl / dist * (x_arr[1] - xx)**2
- *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
- *     for i in range(2, a):             # <<<<<<<<<<<<<<
- *         ph0 = ph1
- *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2
- */
-  __pyx_t_9 = __pyx_v_a;
-  __pyx_t_10 = __pyx_t_9;
-  for (__pyx_t_11 = 2; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
-    __pyx_v_i = __pyx_t_11;
-
-    /* "beam_calc.pyx":111
- *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
- *     for i in range(2, a):
- *         ph0 = ph1             # <<<<<<<<<<<<<<
- *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2
- *         wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
- */
-    __pyx_v_ph0 = __pyx_v_ph1;
-
-    /* "beam_calc.pyx":112
- *     for i in range(2, a):
- *         ph0 = ph1
- *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2             # <<<<<<<<<<<<<<
- *         wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
- *     return wf
- */
-    __pyx_t_12 = __pyx_v_i;
-    __pyx_v_ph1 = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_dist) * pow(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_12)) ))) - __pyx_v_xx), 2.0));
-
-    /* "beam_calc.pyx":113
- *         ph0 = ph1
- *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2
- *         wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])             # <<<<<<<<<<<<<<
- *     return wf
- * 
- */
-    __pyx_t_13 = (__pyx_v_i - 1);
-    __pyx_t_14 = __pyx_v_i;
-    __pyx_t_5 = __Pyx_c_quot_double(__Pyx_c_sum_double(__Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_13)) ))), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph0), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph0), 0)))), __Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_14)) ))), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph1), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph1), 0))))), __pyx_t_double_complex_from_parts(2, 0));
-    __pyx_t_15 = __pyx_v_i;
-    __pyx_t_16 = (__pyx_v_i - 1);
-    __pyx_t_8 = __Pyx_c_sum_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_v_wf), __Pyx_CIMAG(__pyx_v_wf)), __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_5), __Pyx_CIMAG(__pyx_t_5)), __pyx_t_npy_float64_complex_from_parts(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_15)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_16)) )))), 0)));
-    __pyx_v_wf = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_8), __Pyx_CIMAG(__pyx_t_8));
-  }
-
-  /* "beam_calc.pyx":114
- *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2
- *         wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
- *     return wf             # <<<<<<<<<<<<<<
- * 
- * cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
- */
-  __pyx_r = __pyx_v_wf;
-  goto __pyx_L0;
-
-  /* "beam_calc.pyx":102
- *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
- * 
- * cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = wf0.shape[0], i
- */
-
-  /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
-}
-
-/* "beam_calc.pyx":116
- *     return wf
- * 
- * cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = xx_arr.shape[0], i
- */
-
-static void __pyx_f_9beam_calc_fnl_1d(__Pyx_memviewslice __pyx_v_wf1, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
-  __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __pyx_t_9beam_calc_int_t __pyx_t_1;
-  __pyx_t_9beam_calc_int_t __pyx_t_2;
-  __pyx_t_9beam_calc_int_t __pyx_t_3;
-  __pyx_t_9beam_calc_int_t __pyx_t_4;
-  __pyx_t_9beam_calc_int_t __pyx_t_5;
-
-  /* "beam_calc.pyx":118
- * cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
- *     cdef:
- *         int_t a = xx_arr.shape[0], i             # <<<<<<<<<<<<<<
- *     for i in range(a):
- *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
- */
-  __pyx_v_a = (__pyx_v_xx_arr.shape[0]);
-
-  /* "beam_calc.pyx":119
- *     cdef:
- *         int_t a = xx_arr.shape[0], i
- *     for i in range(a):             # <<<<<<<<<<<<<<
- *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
- * 
- */
-  __pyx_t_1 = __pyx_v_a;
-  __pyx_t_2 = __pyx_t_1;
-  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
-    __pyx_v_i = __pyx_t_3;
-
-    /* "beam_calc.pyx":120
- *         int_t a = xx_arr.shape[0], i
- *     for i in range(a):
- *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)             # <<<<<<<<<<<<<<
- * 
- * def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
- */
-    __pyx_t_4 = __pyx_v_i;
-    __pyx_t_5 = __pyx_v_i;
-    *((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf1.data) + __pyx_t_5)) )) = __pyx_f_9beam_calc_fnl_wp(__pyx_v_wf0, __pyx_v_x_arr, (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_xx_arr.data) + __pyx_t_4)) ))), __pyx_v_dist, __pyx_v_wl);
-  }
-
-  /* "beam_calc.pyx":116
- *     return wf
- * 
- * cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = xx_arr.shape[0], i
- */
-
-  /* function exit code */
-}
-
-/* "beam_calc.pyx":122
- *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
- * 
- * def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
- *     """
- *     1D Fraunhofer diffraction calculation (without the coefficient)
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_1fraunhofer_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_fraunhofer_1d[] = "\n    1D Fraunhofer diffraction calculation (without the coefficient)\n\n    wf0 - wavefront at the plane downstream\n    x_arr - coordinates at the plane downstream [um]\n    xx_arr - coordinates at the plane upstream [um]\n    dist - distance between planes [um]\n    wl - wavelength [um]\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_1fraunhofer_1d = {"fraunhofer_1d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_1fraunhofer_1d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_fraunhofer_1d};
-static PyObject *__pyx_pw_9beam_calc_1fraunhofer_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  __Pyx_memviewslice __pyx_v_wf0 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_xx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_float_t __pyx_v_dist;
-  __pyx_t_9beam_calc_float_t __pyx_v_wl;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("fraunhofer_1d (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_wf0,&__pyx_n_s_x_arr,&__pyx_n_s_xx_arr,&__pyx_n_s_dist,&__pyx_n_s_wl,0};
-    PyObject* values[5] = {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  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_wf0)) != 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_x_arr)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, 1); __PYX_ERR(0, 122, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xx_arr)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, 2); __PYX_ERR(0, 122, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, 3); __PYX_ERR(0, 122, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, 4); __PYX_ERR(0, 122, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fraunhofer_1d") < 0)) __PYX_ERR(0, 122, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
-      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);
-    }
-    __pyx_v_wf0 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_wf0.memview)) __PYX_ERR(0, 122, __pyx_L3_error)
-    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 122, __pyx_L3_error)
-    __pyx_v_xx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_xx_arr.memview)) __PYX_ERR(0, 122, __pyx_L3_error)
-    __pyx_v_dist = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_dist == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L3_error)
-    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 122, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("beam_calc.fraunhofer_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_fraunhofer_1d(__pyx_self, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_9beam_calc_fraunhofer_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
-  __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_RefNannySetupContext("fraunhofer_1d", 0);
-
-  /* "beam_calc.pyx":133
- *     """
- *     cdef:
- *         int_t a = xx_arr.shape[0]             # <<<<<<<<<<<<<<
- *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
- *     fhf_1d(wf, wf0, x_arr, xx_arr, dist, wl)
- */
-  __pyx_v_a = (__pyx_v_xx_arr.shape[0]);
-
-  /* "beam_calc.pyx":134
- *     cdef:
- *         int_t a = xx_arr.shape[0]
- *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)             # <<<<<<<<<<<<<<
- *     fhf_1d(wf, wf0, x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)
- */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
-  __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_wf = __pyx_t_6;
-  __pyx_t_6.memview = NULL;
-  __pyx_t_6.data = NULL;
-
-  /* "beam_calc.pyx":135
- *         int_t a = xx_arr.shape[0]
- *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
- *     fhf_1d(wf, wf0, x_arr, xx_arr, dist, wl)             # <<<<<<<<<<<<<<
- *     return np.asarray(wf)
- * 
- */
-  __pyx_f_9beam_calc_fhf_1d(__pyx_v_wf, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
-
-  /* "beam_calc.pyx":136
- *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
- *     fhf_1d(wf, wf0, x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)             # <<<<<<<<<<<<<<
- * 
- * def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_wf, 1, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
-    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
-    if (likely(__pyx_t_2)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
-      __Pyx_INCREF(__pyx_t_2);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_1, function);
-    }
-  }
-  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 136, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_5;
-  __pyx_t_5 = 0;
-  goto __pyx_L0;
-
-  /* "beam_calc.pyx":122
- *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
- * 
- * def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
- *     """
- *     1D Fraunhofer diffraction calculation (without the coefficient)
- */
-
-  /* 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_6, 1);
-  __Pyx_AddTraceback("beam_calc.fraunhofer_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wf0, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_xx_arr, 1);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "beam_calc.pyx":138
- *     return np.asarray(wf)
- * 
- * def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
- *     """
- *     1D Fraunhofer diffraction calculation for an array of wavefronts (without the coefficient)
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_3fraunhofer_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_2fraunhofer_2d[] = "\n    1D Fraunhofer diffraction calculation for an array of wavefronts (without the coefficient)\n\n    wf0 - an array of wavefronts at the plane downstream\n    x_arr - coordinates at the plane downstream [um]\n    xx_arr - coordinates at the plane upstream [um]\n    dist - distance between planes [um]\n    wl - wavelength [um]\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_3fraunhofer_2d = {"fraunhofer_2d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_3fraunhofer_2d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_2fraunhofer_2d};
-static PyObject *__pyx_pw_9beam_calc_3fraunhofer_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  __Pyx_memviewslice __pyx_v_wf0 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_xx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_float_t __pyx_v_dist;
-  __pyx_t_9beam_calc_float_t __pyx_v_wl;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("fraunhofer_2d (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_wf0,&__pyx_n_s_x_arr,&__pyx_n_s_xx_arr,&__pyx_n_s_dist,&__pyx_n_s_wl,0};
-    PyObject* values[5] = {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  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_wf0)) != 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_x_arr)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, 1); __PYX_ERR(0, 138, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xx_arr)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, 2); __PYX_ERR(0, 138, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, 3); __PYX_ERR(0, 138, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, 4); __PYX_ERR(0, 138, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fraunhofer_2d") < 0)) __PYX_ERR(0, 138, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
-      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);
-    }
-    __pyx_v_wf0 = __Pyx_PyObject_to_MemoryviewSlice_d_dc___pyx_t_double_complex(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_wf0.memview)) __PYX_ERR(0, 138, __pyx_L3_error)
-    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 138, __pyx_L3_error)
-    __pyx_v_xx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_xx_arr.memview)) __PYX_ERR(0, 138, __pyx_L3_error)
-    __pyx_v_dist = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_dist == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 138, __pyx_L3_error)
-    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 138, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 138, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("beam_calc.fraunhofer_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_2fraunhofer_2d(__pyx_self, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_9beam_calc_2fraunhofer_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
-  __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_b;
-  __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_int_t __pyx_t_7;
-  __pyx_t_9beam_calc_int_t __pyx_t_8;
-  __pyx_t_9beam_calc_int_t __pyx_t_9;
-  __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_RefNannySetupContext("fraunhofer_2d", 0);
-
-  /* "beam_calc.pyx":149
- *     """
- *     cdef:
- *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i             # <<<<<<<<<<<<<<
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True):
- */
-  __pyx_v_a = (__pyx_v_wf0.shape[0]);
-  __pyx_v_b = (__pyx_v_xx_arr.shape[0]);
-
-  /* "beam_calc.pyx":150
- *     cdef:
- *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)             # <<<<<<<<<<<<<<
- *     for i in prange(a, schedule='guided', nogil=True):
- *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
- */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
-  __pyx_t_1 = 0;
-  __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
-  __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_wf = __pyx_t_6;
-  __pyx_t_6.memview = NULL;
-  __pyx_t_6.data = NULL;
-
-  /* "beam_calc.pyx":151
- *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)
- */
-  {
-      #ifdef WITH_THREAD
-      PyThreadState *_save;
-      Py_UNBLOCK_THREADS
-      __Pyx_FastGIL_Remember();
-      #endif
-      /*try:*/ {
-        __pyx_t_7 = __pyx_v_a;
-        if ((1 == 0)) abort();
-        {
-            __pyx_t_9beam_calc_int_t __pyx_parallel_temp0 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
-            const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0;
-            PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL;
-            int __pyx_parallel_why;
-            __pyx_parallel_why = 0;
-            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
-                #undef likely
-                #undef unlikely
-                #define likely(x)   (x)
-                #define unlikely(x) (x)
-            #endif
-            __pyx_t_9 = (__pyx_t_7 - 0 + 1 - 1/abs(1)) / 1;
-            if (__pyx_t_9 > 0)
-            {
-                #ifdef _OPENMP
-                #pragma omp parallel firstprivate(__pyx_t_10, __pyx_t_11) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb)
-                #endif /* _OPENMP */
-                {
-                    #ifdef _OPENMP
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    Py_BEGIN_ALLOW_THREADS
-                    #endif /* _OPENMP */
-                    #ifdef _OPENMP
-                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) schedule(guided)
-                    #endif /* _OPENMP */
-                    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
-                        if (__pyx_parallel_why < 2)
-                        {
-                            __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
-
-                            /* "beam_calc.pyx":152
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True):
- *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)             # <<<<<<<<<<<<<<
- *     return np.asarray(wf)
- * 
- */
-                            __pyx_t_10.data = __pyx_v_wf.data;
-                            __pyx_t_10.memview = __pyx_v_wf.memview;
-                            __PYX_INC_MEMVIEW(&__pyx_t_10, 0);
-                            {
-    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_wf.strides[0];
-        if ((0)) __PYX_ERR(0, 152, __pyx_L8_error)
-        __pyx_t_10.data += __pyx_tmp_idx * __pyx_tmp_stride;
-}
-
-__pyx_t_10.shape[0] = __pyx_v_wf.shape[1];
-__pyx_t_10.strides[0] = __pyx_v_wf.strides[1];
-    __pyx_t_10.suboffsets[0] = -1;
-
-__pyx_t_11.data = __pyx_v_wf0.data;
-                            __pyx_t_11.memview = __pyx_v_wf0.memview;
-                            __PYX_INC_MEMVIEW(&__pyx_t_11, 0);
-                            {
-    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_wf0.strides[0];
-        if ((0)) __PYX_ERR(0, 152, __pyx_L8_error)
-        __pyx_t_11.data += __pyx_tmp_idx * __pyx_tmp_stride;
-}
-
-__pyx_t_11.shape[0] = __pyx_v_wf0.shape[1];
-__pyx_t_11.strides[0] = __pyx_v_wf0.strides[1];
-    __pyx_t_11.suboffsets[0] = -1;
-
-__pyx_f_9beam_calc_fhf_1d(__pyx_t_10, __pyx_t_11, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
-                            __PYX_XDEC_MEMVIEW(&__pyx_t_10, 0);
-                            __pyx_t_10.memview = NULL;
-                            __pyx_t_10.data = NULL;
-                            __PYX_XDEC_MEMVIEW(&__pyx_t_11, 0);
-                            __pyx_t_11.memview = NULL;
-                            __pyx_t_11.data = NULL;
-                            goto __pyx_L11;
-                            __pyx_L8_error:;
-                            {
-                                #ifdef WITH_THREAD
-                                PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                                #endif
-                                #ifdef _OPENMP
-                                #pragma omp flush(__pyx_parallel_exc_type)
-                                #endif /* _OPENMP */
-                                if (!__pyx_parallel_exc_type) {
-                                  __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
-                                  __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
-                                  __Pyx_GOTREF(__pyx_parallel_exc_type);
-                                }
-                                #ifdef WITH_THREAD
-                                __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                                #endif
-                            }
-                            __pyx_parallel_why = 4;
-                            goto __pyx_L10;
-                            __pyx_L10:;
-                            #ifdef _OPENMP
-                            #pragma omp critical(__pyx_parallel_lastprivates0)
-                            #endif /* _OPENMP */
-                            {
-                                __pyx_parallel_temp0 = __pyx_v_i;
-                            }
-                            __pyx_L11:;
-                            #ifdef _OPENMP
-                            #pragma omp flush(__pyx_parallel_why)
-                            #endif /* _OPENMP */
-                        }
-                    }
-                    #ifdef _OPENMP
-                    Py_END_ALLOW_THREADS
-                    #else
-{
-#ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    #endif /* _OPENMP */
-                    /* Clean up any temporaries */
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_10, 0);
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_11, 0);
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
-                    #ifndef _OPENMP
-}
-#endif /* _OPENMP */
-                }
-            }
-            if (__pyx_parallel_exc_type) {
-              /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
-              __pyx_parallel_why = 4;
-            }
-            if (__pyx_parallel_why) {
-              __pyx_v_i = __pyx_parallel_temp0;
-              switch (__pyx_parallel_why) {
-                    case 4:
-                {
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    __Pyx_GIVEREF(__pyx_parallel_exc_type);
-                    __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
-                    __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
-                }
-                goto __pyx_L4_error;
-              }
-            }
-        }
-        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
-            #undef likely
-            #undef unlikely
-            #define likely(x)   __builtin_expect(!!(x), 1)
-            #define unlikely(x) __builtin_expect(!!(x), 0)
-        #endif
-      }
-
-      /* "beam_calc.pyx":151
- *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)
- */
-      /*finally:*/ {
-        /*normal exit:*/{
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L5;
-        }
-        __pyx_L4_error: {
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L1_error;
-        }
-        __pyx_L5:;
-      }
-  }
-
-  /* "beam_calc.pyx":153
- *     for i in prange(a, schedule='guided', nogil=True):
- *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)             # <<<<<<<<<<<<<<
- * 
- * def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_wf, 2, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(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_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 153, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_5;
-  __pyx_t_5 = 0;
-  goto __pyx_L0;
-
-  /* "beam_calc.pyx":138
- *     return np.asarray(wf)
- * 
- * def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
- *     """
- *     1D Fraunhofer diffraction calculation for an array of wavefronts (without the coefficient)
- */
-
-  /* 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_6, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
-  __Pyx_AddTraceback("beam_calc.fraunhofer_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wf0, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_xx_arr, 1);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "beam_calc.pyx":155
- *     return np.asarray(wf)
- * 
- * def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
- *     """
- *     1D Fresnel diffraction calculation (without the coefficient)
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_5fresnel_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_4fresnel_1d[] = "\n    1D Fresnel diffraction calculation (without the coefficient)\n\n    wf0 - wavefront at the plane downstream\n    x_arr - coordinates at the plane downstream [um]\n    xx_arr - coordinates at the plane upstream [um]\n    dist - distance between planes [um]\n    wl - wavelength [um]\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_5fresnel_1d = {"fresnel_1d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_5fresnel_1d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_4fresnel_1d};
-static PyObject *__pyx_pw_9beam_calc_5fresnel_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  __Pyx_memviewslice __pyx_v_wf0 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_xx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_float_t __pyx_v_dist;
-  __pyx_t_9beam_calc_float_t __pyx_v_wl;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("fresnel_1d (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_wf0,&__pyx_n_s_x_arr,&__pyx_n_s_xx_arr,&__pyx_n_s_dist,&__pyx_n_s_wl,0};
-    PyObject* values[5] = {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  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_wf0)) != 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_x_arr)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, 1); __PYX_ERR(0, 155, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xx_arr)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, 2); __PYX_ERR(0, 155, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, 3); __PYX_ERR(0, 155, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, 4); __PYX_ERR(0, 155, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fresnel_1d") < 0)) __PYX_ERR(0, 155, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
-      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);
-    }
-    __pyx_v_wf0 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_wf0.memview)) __PYX_ERR(0, 155, __pyx_L3_error)
-    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 155, __pyx_L3_error)
-    __pyx_v_xx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_xx_arr.memview)) __PYX_ERR(0, 155, __pyx_L3_error)
-    __pyx_v_dist = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_dist == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L3_error)
-    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 155, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("beam_calc.fresnel_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_4fresnel_1d(__pyx_self, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_9beam_calc_4fresnel_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
-  __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_RefNannySetupContext("fresnel_1d", 0);
-
-  /* "beam_calc.pyx":166
- *     """
- *     cdef:
- *         int_t a = xx_arr.shape[0]             # <<<<<<<<<<<<<<
- *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
- *     fnl_1d(wf, wf0, x_arr, xx_arr, dist, wl)
- */
-  __pyx_v_a = (__pyx_v_xx_arr.shape[0]);
-
-  /* "beam_calc.pyx":167
- *     cdef:
- *         int_t a = xx_arr.shape[0]
- *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)             # <<<<<<<<<<<<<<
- *     fnl_1d(wf, wf0, x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)
- */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
-  __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 167, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_wf = __pyx_t_6;
-  __pyx_t_6.memview = NULL;
-  __pyx_t_6.data = NULL;
-
-  /* "beam_calc.pyx":168
- *         int_t a = xx_arr.shape[0]
- *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
- *     fnl_1d(wf, wf0, x_arr, xx_arr, dist, wl)             # <<<<<<<<<<<<<<
- *     return np.asarray(wf)
- * 
- */
-  __pyx_f_9beam_calc_fnl_1d(__pyx_v_wf, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
-
-  /* "beam_calc.pyx":169
- *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
- *     fnl_1d(wf, wf0, x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)             # <<<<<<<<<<<<<<
- * 
- * def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
- */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 169, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_wf, 1, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
-    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
-    if (likely(__pyx_t_2)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
-      __Pyx_INCREF(__pyx_t_2);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_1, function);
-    }
-  }
-  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_5;
-  __pyx_t_5 = 0;
-  goto __pyx_L0;
-
-  /* "beam_calc.pyx":155
- *     return np.asarray(wf)
- * 
- * def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
- *     """
- *     1D Fresnel diffraction calculation (without the coefficient)
- */
-
-  /* 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_6, 1);
-  __Pyx_AddTraceback("beam_calc.fresnel_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wf0, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_xx_arr, 1);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "beam_calc.pyx":171
- *     return np.asarray(wf)
- * 
- * def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
- *     """
- *     1D Fresnel diffraction calculation for an array of wavefronts (without the coefficient)
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_7fresnel_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_6fresnel_2d[] = "\n    1D Fresnel diffraction calculation for an array of wavefronts (without the coefficient)\n\n    wf0 - an array of wavefronts at the plane downstream\n    x_arr - coordinates at the plane downstream [um]\n    xx_arr - coordinates at the plane upstream [um]\n    dist - distance between planes [um]\n    wl - wavelength [um]\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_7fresnel_2d = {"fresnel_2d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_7fresnel_2d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_6fresnel_2d};
-static PyObject *__pyx_pw_9beam_calc_7fresnel_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  __Pyx_memviewslice __pyx_v_wf0 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_xx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_float_t __pyx_v_dist;
+/* Python wrapper */
+static PyObject *__pyx_pw_9beam_calc_1lens(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_lens[] = "\n    Lens wavefront calculation by dint of Fresnel diffraction (without the coefficient)\n    with third order polinomial abberations\n\n    x_arr - coordinates at the plane downstream [um]\n    wl - wavelength [um]\n    ap - lens' size [um]\n    focus - focal distance [um]\n    defoc - defocus [um]\n    alpha - abberations coefficient [rad/mrad^3]\n    x0 - center point of the lens' abberations [um]\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_1lens = {"lens", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_1lens, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_lens};
+static PyObject *__pyx_pw_9beam_calc_1lens(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
   __pyx_t_9beam_calc_float_t __pyx_v_wl;
+  __pyx_t_9beam_calc_float_t __pyx_v_ap;
+  __pyx_t_9beam_calc_float_t __pyx_v_focus;
+  __pyx_t_9beam_calc_float_t __pyx_v_defoc;
+  __pyx_t_9beam_calc_float_t __pyx_v_alpha;
+  __pyx_t_9beam_calc_float_t __pyx_v_x0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("fresnel_2d (wrapper)", 0);
+  __Pyx_RefNannySetupContext("lens (wrapper)", 0);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_wf0,&__pyx_n_s_x_arr,&__pyx_n_s_xx_arr,&__pyx_n_s_dist,&__pyx_n_s_wl,0};
-    PyObject* values[5] = {0,0,0,0,0};
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_arr,&__pyx_n_s_wl,&__pyx_n_s_ap,&__pyx_n_s_focus,&__pyx_n_s_defoc,&__pyx_n_s_alpha,&__pyx_n_s_x0,0};
+    PyObject* values[7] = {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  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);
@@ -5095,37 +3561,49 @@ static PyObject *__pyx_pw_9beam_calc_7fresnel_2d(PyObject *__pyx_self, PyObject
       kw_args = PyDict_Size(__pyx_kwds);
       switch (pos_args) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wf0)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_arr)) != 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_x_arr)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, 1); __PYX_ERR(0, 171, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("lens", 1, 7, 7, 1); __PYX_ERR(0, 60, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xx_arr)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ap)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, 2); __PYX_ERR(0, 171, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("lens", 1, 7, 7, 2); __PYX_ERR(0, 60, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_focus)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, 3); __PYX_ERR(0, 171, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("lens", 1, 7, 7, 3); __PYX_ERR(0, 60, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defoc)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("lens", 1, 7, 7, 4); __PYX_ERR(0, 60, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  5:
+        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("lens", 1, 7, 7, 5); __PYX_ERR(0, 60, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  6:
+        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x0)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, 4); __PYX_ERR(0, 171, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("lens", 1, 7, 7, 6); __PYX_ERR(0, 60, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fresnel_2d") < 0)) __PYX_ERR(0, 171, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "lens") < 0)) __PYX_ERR(0, 60, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 7) {
       goto __pyx_L5_argtuple_error;
     } else {
       values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
@@ -5133,33 +3611,36 @@ static PyObject *__pyx_pw_9beam_calc_7fresnel_2d(PyObject *__pyx_self, PyObject
       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);
     }
-    __pyx_v_wf0 = __Pyx_PyObject_to_MemoryviewSlice_d_dc___pyx_t_double_complex(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_wf0.memview)) __PYX_ERR(0, 171, __pyx_L3_error)
-    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 171, __pyx_L3_error)
-    __pyx_v_xx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_xx_arr.memview)) __PYX_ERR(0, 171, __pyx_L3_error)
-    __pyx_v_dist = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_dist == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L3_error)
-    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L3_error)
+    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 60, __pyx_L3_error)
+    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 60, __pyx_L3_error)
+    __pyx_v_ap = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ap == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 60, __pyx_L3_error)
+    __pyx_v_focus = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_focus == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 60, __pyx_L3_error)
+    __pyx_v_defoc = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_defoc == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error)
+    __pyx_v_alpha = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_alpha == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error)
+    __pyx_v_x0 = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_x0 == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 171, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("lens", 1, 7, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 60, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("beam_calc.fresnel_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("beam_calc.lens", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_6fresnel_2d(__pyx_self, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
+  __pyx_r = __pyx_pf_9beam_calc_lens(__pyx_self, __pyx_v_x_arr, __pyx_v_wl, __pyx_v_ap, __pyx_v_focus, __pyx_v_defoc, __pyx_v_alpha, __pyx_v_x0);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_9beam_calc_6fresnel_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
+static PyObject *__pyx_pf_9beam_calc_lens(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap, __pyx_t_9beam_calc_float_t __pyx_v_focus, __pyx_t_9beam_calc_float_t __pyx_v_defoc, __pyx_t_9beam_calc_float_t __pyx_v_alpha, __pyx_t_9beam_calc_float_t __pyx_v_x0) {
   __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_b;
   __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_wave_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
@@ -5171,75 +3652,73 @@ static PyObject *__pyx_pf_9beam_calc_6fresnel_2d(CYTHON_UNUSED PyObject *__pyx_s
   __pyx_t_9beam_calc_int_t __pyx_t_7;
   __pyx_t_9beam_calc_int_t __pyx_t_8;
   __pyx_t_9beam_calc_int_t __pyx_t_9;
-  __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_RefNannySetupContext("fresnel_2d", 0);
+  int __pyx_t_10;
+  __pyx_t_9beam_calc_int_t __pyx_t_11;
+  __pyx_t_9beam_calc_int_t __pyx_t_12;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("lens", 0);
 
-  /* "beam_calc.pyx":182
+  /* "beam_calc.pyx":75
  *     """
  *     cdef:
- *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i             # <<<<<<<<<<<<<<
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True):
+ *         int_t a = x_arr.shape[0], i             # <<<<<<<<<<<<<<
+ *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
  */
-  __pyx_v_a = (__pyx_v_wf0.shape[0]);
-  __pyx_v_b = (__pyx_v_xx_arr.shape[0]);
+  __pyx_v_a = (__pyx_v_x_arr.shape[0]);
 
-  /* "beam_calc.pyx":183
+  /* "beam_calc.pyx":76
  *     cdef:
- *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)             # <<<<<<<<<<<<<<
- *     for i in prange(a, schedule='guided', nogil=True):
- *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
+ *         int_t a = x_arr.shape[0], i
+ *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)             # <<<<<<<<<<<<<<
+ *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
+ *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha, x0)
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
   __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
   __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
-  __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_wf = __pyx_t_6;
+  __pyx_v_wave_arr = __pyx_t_6;
   __pyx_t_6.memview = NULL;
   __pyx_t_6.data = NULL;
 
-  /* "beam_calc.pyx":184
- *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)
+  /* "beam_calc.pyx":77
+ *         int_t a = x_arr.shape[0], i
+ *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):             # <<<<<<<<<<<<<<
+ *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha, x0)
+ *     return np.asarray(wave_arr)
  */
   {
       #ifdef WITH_THREAD
@@ -5251,11 +3730,7 @@ static PyObject *__pyx_pf_9beam_calc_6fresnel_2d(CYTHON_UNUSED PyObject *__pyx_s
         __pyx_t_7 = __pyx_v_a;
         if ((1 == 0)) abort();
         {
-            __pyx_t_9beam_calc_int_t __pyx_parallel_temp0 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
-            const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0;
-            PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL;
-            int __pyx_parallel_why;
-            __pyx_parallel_why = 0;
+            __pyx_t_10 = 10;
             #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                 #undef likely
                 #undef unlikely
@@ -5266,138 +3741,29 @@ static PyObject *__pyx_pf_9beam_calc_6fresnel_2d(CYTHON_UNUSED PyObject *__pyx_s
             if (__pyx_t_9 > 0)
             {
                 #ifdef _OPENMP
-                #pragma omp parallel firstprivate(__pyx_t_10, __pyx_t_11) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb)
+                #pragma omp parallel private(__pyx_t_11, __pyx_t_12)
                 #endif /* _OPENMP */
                 {
                     #ifdef _OPENMP
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    Py_BEGIN_ALLOW_THREADS
-                    #endif /* _OPENMP */
-                    #ifdef _OPENMP
-                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) schedule(guided)
-                    #endif /* _OPENMP */
-                    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
-                        if (__pyx_parallel_why < 2)
-                        {
-                            __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
-
-                            /* "beam_calc.pyx":185
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True):
- *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)             # <<<<<<<<<<<<<<
- *     return np.asarray(wf)
- * 
- */
-                            __pyx_t_10.data = __pyx_v_wf.data;
-                            __pyx_t_10.memview = __pyx_v_wf.memview;
-                            __PYX_INC_MEMVIEW(&__pyx_t_10, 0);
-                            {
-    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_wf.strides[0];
-        if ((0)) __PYX_ERR(0, 185, __pyx_L8_error)
-        __pyx_t_10.data += __pyx_tmp_idx * __pyx_tmp_stride;
-}
-
-__pyx_t_10.shape[0] = __pyx_v_wf.shape[1];
-__pyx_t_10.strides[0] = __pyx_v_wf.strides[1];
-    __pyx_t_10.suboffsets[0] = -1;
-
-__pyx_t_11.data = __pyx_v_wf0.data;
-                            __pyx_t_11.memview = __pyx_v_wf0.memview;
-                            __PYX_INC_MEMVIEW(&__pyx_t_11, 0);
-                            {
-    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_wf0.strides[0];
-        if ((0)) __PYX_ERR(0, 185, __pyx_L8_error)
-        __pyx_t_11.data += __pyx_tmp_idx * __pyx_tmp_stride;
-}
-
-__pyx_t_11.shape[0] = __pyx_v_wf0.shape[1];
-__pyx_t_11.strides[0] = __pyx_v_wf0.strides[1];
-    __pyx_t_11.suboffsets[0] = -1;
-
-__pyx_f_9beam_calc_fnl_1d(__pyx_t_10, __pyx_t_11, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
-                            __PYX_XDEC_MEMVIEW(&__pyx_t_10, 0);
-                            __pyx_t_10.memview = NULL;
-                            __pyx_t_10.data = NULL;
-                            __PYX_XDEC_MEMVIEW(&__pyx_t_11, 0);
-                            __pyx_t_11.memview = NULL;
-                            __pyx_t_11.data = NULL;
-                            goto __pyx_L11;
-                            __pyx_L8_error:;
-                            {
-                                #ifdef WITH_THREAD
-                                PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                                #endif
-                                #ifdef _OPENMP
-                                #pragma omp flush(__pyx_parallel_exc_type)
-                                #endif /* _OPENMP */
-                                if (!__pyx_parallel_exc_type) {
-                                  __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
-                                  __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
-                                  __Pyx_GOTREF(__pyx_parallel_exc_type);
-                                }
-                                #ifdef WITH_THREAD
-                                __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                                #endif
-                            }
-                            __pyx_parallel_why = 4;
-                            goto __pyx_L10;
-                            __pyx_L10:;
-                            #ifdef _OPENMP
-                            #pragma omp critical(__pyx_parallel_lastprivates1)
-                            #endif /* _OPENMP */
-                            {
-                                __pyx_parallel_temp0 = __pyx_v_i;
-                            }
-                            __pyx_L11:;
-                            #ifdef _OPENMP
-                            #pragma omp flush(__pyx_parallel_why)
-                            #endif /* _OPENMP */
-                        }
-                    }
-                    #ifdef _OPENMP
-                    Py_END_ALLOW_THREADS
-                    #else
-{
-#ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    #endif /* _OPENMP */
-                    /* Clean up any temporaries */
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_10, 0);
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_11, 0);
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
-                    #ifndef _OPENMP
-}
-#endif /* _OPENMP */
-                }
-            }
-            if (__pyx_parallel_exc_type) {
-              /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
-              __pyx_parallel_why = 4;
-            }
-            if (__pyx_parallel_why) {
-              __pyx_v_i = __pyx_parallel_temp0;
-              switch (__pyx_parallel_why) {
-                    case 4:
-                {
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    __Pyx_GIVEREF(__pyx_parallel_exc_type);
-                    __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
-                    __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
+                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) schedule(guided, __pyx_t_10)
+                    #endif /* _OPENMP */
+                    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
+                        {
+                            __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
+
+                            /* "beam_calc.pyx":78
+ *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
+ *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha, x0)             # <<<<<<<<<<<<<<
+ *     return np.asarray(wave_arr)
+ * 
+ */
+                            __pyx_t_11 = __pyx_v_i;
+                            __pyx_t_12 = __pyx_v_i;
+                            *((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wave_arr.data) + __pyx_t_12)) )) = __pyx_f_9beam_calc_lens_wp((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_11)) ))), __pyx_v_wl, __pyx_v_ap, __pyx_v_focus, __pyx_v_defoc, __pyx_v_alpha, __pyx_v_x0);
+                        }
+                    }
                 }
-                goto __pyx_L4_error;
-              }
             }
         }
         #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
@@ -5408,12 +3774,12 @@ __pyx_f_9beam_calc_fnl_1d(__pyx_t_10, __pyx_t_11, __pyx_v_x_arr, __pyx_v_xx_arr,
         #endif
       }
 
-      /* "beam_calc.pyx":184
- *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
- *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)
+      /* "beam_calc.pyx":77
+ *         int_t a = x_arr.shape[0], i
+ *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):             # <<<<<<<<<<<<<<
+ *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha, x0)
+ *     return np.asarray(wave_arr)
  */
       /*finally:*/ {
         /*normal exit:*/{
@@ -5423,84 +3789,269 @@ __pyx_f_9beam_calc_fnl_1d(__pyx_t_10, __pyx_t_11, __pyx_v_x_arr, __pyx_v_xx_arr,
           #endif
           goto __pyx_L5;
         }
-        __pyx_L4_error: {
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L1_error;
-        }
         __pyx_L5:;
       }
   }
 
-  /* "beam_calc.pyx":186
- *     for i in prange(a, schedule='guided', nogil=True):
- *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
- *     return np.asarray(wf)             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":79
+ *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
+ *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha, x0)
+ *     return np.asarray(wave_arr)             # <<<<<<<<<<<<<<
+ * 
+ * cdef float_t aperture_re(float_t xx, void* params) nogil:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_wave_arr, 1, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "beam_calc.pyx":60
+ * 
+ * 
+ * def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,             # <<<<<<<<<<<<<<
+ *          float_t defoc, float_t alpha, float_t x0):
+ *     """
+ */
+
+  /* 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_6, 1);
+  __Pyx_AddTraceback("beam_calc.lens", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wave_arr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":81
+ *     return np.asarray(wave_arr)
+ * 
+ * cdef float_t aperture_re(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
+ */
+
+static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_aperture_re(__pyx_t_9beam_calc_float_t __pyx_v_xx, void *__pyx_v_params) {
+  __pyx_t_9beam_calc_float_t __pyx_v_x;
+  __pyx_t_9beam_calc_float_t __pyx_v_z;
+  __pyx_t_9beam_calc_float_t __pyx_v_wl;
+  __pyx_t_9beam_calc_float_t __pyx_r;
+
+  /* "beam_calc.pyx":83
+ * cdef float_t aperture_re(float_t xx, void* params) nogil:
+ *     cdef:
+ *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]             # <<<<<<<<<<<<<<
+ *     return cos(pi / wl / z * (x - xx)**2)
+ * 
+ */
+  __pyx_v_x = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[0]);
+  __pyx_v_z = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[1]);
+  __pyx_v_wl = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[2]);
+
+  /* "beam_calc.pyx":84
+ *     cdef:
+ *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
+ *     return cos(pi / wl / z * (x - xx)**2)             # <<<<<<<<<<<<<<
+ * 
+ * cdef float_t aperture_im(float_t xx, void* params) nogil:
+ */
+  __pyx_r = cos((((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_z) * pow((__pyx_v_x - __pyx_v_xx), 2.0)));
+  goto __pyx_L0;
+
+  /* "beam_calc.pyx":81
+ *     return np.asarray(wave_arr)
+ * 
+ * cdef float_t aperture_re(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":86
+ *     return cos(pi / wl / z * (x - xx)**2)
+ * 
+ * cdef float_t aperture_im(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
+ */
+
+static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_aperture_im(__pyx_t_9beam_calc_float_t __pyx_v_xx, void *__pyx_v_params) {
+  __pyx_t_9beam_calc_float_t __pyx_v_x;
+  __pyx_t_9beam_calc_float_t __pyx_v_z;
+  __pyx_t_9beam_calc_float_t __pyx_v_wl;
+  __pyx_t_9beam_calc_float_t __pyx_r;
+
+  /* "beam_calc.pyx":88
+ * cdef float_t aperture_im(float_t xx, void* params) nogil:
+ *     cdef:
+ *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]             # <<<<<<<<<<<<<<
+ *     return sin(pi / wl / z * (x - xx)**2)
+ * 
+ */
+  __pyx_v_x = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[0]);
+  __pyx_v_z = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[1]);
+  __pyx_v_wl = (((__pyx_t_9beam_calc_float_t *)__pyx_v_params)[2]);
+
+  /* "beam_calc.pyx":89
+ *     cdef:
+ *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
+ *     return sin(pi / wl / z * (x - xx)**2)             # <<<<<<<<<<<<<<
+ * 
+ * cdef complex_t aperture_wp(float_t x, float_t z, float_t wl, float_t ap) nogil:
+ */
+  __pyx_r = sin((((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_z) * pow((__pyx_v_x - __pyx_v_xx), 2.0)));
+  goto __pyx_L0;
+
+  /* "beam_calc.pyx":86
+ *     return cos(pi / wl / z * (x - xx)**2)
+ * 
+ * cdef float_t aperture_im(float_t xx, void* params) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":91
+ *     return sin(pi / wl / z * (x - xx)**2)
+ * 
+ * cdef complex_t aperture_wp(float_t x, float_t z, float_t wl, float_t ap) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         float_t re, im
+ */
+
+static __pyx_t_double_complex __pyx_f_9beam_calc_aperture_wp(__pyx_t_9beam_calc_float_t __pyx_v_x, __pyx_t_9beam_calc_float_t __pyx_v_z, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap) {
+  __pyx_t_9beam_calc_float_t __pyx_v_re;
+  __pyx_t_9beam_calc_float_t __pyx_v_im;
+  __pyx_t_9beam_calc_float_t __pyx_v_params[3];
+  __pyx_t_9beam_calc_int_t __pyx_v_fn;
+  gsl_function __pyx_v_func;
+  __pyx_t_double_complex __pyx_r;
+  __pyx_t_double_complex __pyx_t_1;
+  __pyx_t_npy_float64_complex __pyx_t_2;
+
+  /* "beam_calc.pyx":95
+ *         float_t re, im
+ *         float_t params[3]
+ *         int_t fn = <int_t> (ap**2 / wl / z)             # <<<<<<<<<<<<<<
+ *         gsl_function func
+ *     params[0] = x; params[1] = z; params[2] = wl
+ */
+  __pyx_v_fn = ((__pyx_t_9beam_calc_int_t)((pow(__pyx_v_ap, 2.0) / __pyx_v_wl) / __pyx_v_z));
+
+  /* "beam_calc.pyx":97
+ *         int_t fn = <int_t> (ap**2 / wl / z)
+ *         gsl_function func
+ *     params[0] = x; params[1] = z; params[2] = wl             # <<<<<<<<<<<<<<
+ *     func.function = &aperture_re; func.params = params
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ */
+  (__pyx_v_params[0]) = __pyx_v_x;
+  (__pyx_v_params[1]) = __pyx_v_z;
+  (__pyx_v_params[2]) = __pyx_v_wl;
+
+  /* "beam_calc.pyx":98
+ *         gsl_function func
+ *     params[0] = x; params[1] = z; params[2] = wl
+ *     func.function = &aperture_re; func.params = params             # <<<<<<<<<<<<<<
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     func.function = &aperture_im
+ */
+  __pyx_v_func.function = (&__pyx_f_9beam_calc_aperture_re);
+  __pyx_v_func.params = __pyx_v_params;
+
+  /* "beam_calc.pyx":99
+ *     params[0] = x; params[1] = z; params[2] = wl
+ *     func.function = &aperture_re; func.params = params
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)             # <<<<<<<<<<<<<<
+ *     func.function = &aperture_im
+ *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ */
+  __pyx_v_re = __pyx_f_9beam_calc_gsl_quad(__pyx_v_func, ((-__pyx_v_ap) / 2.0), (__pyx_v_ap / 2.0), 1e-9, 1e-7, (0x3E8 * __pyx_v_fn));
+
+  /* "beam_calc.pyx":100
+ *     func.function = &aperture_re; func.params = params
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     func.function = &aperture_im             # <<<<<<<<<<<<<<
+ *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     return re + 1j * im
+ */
+  __pyx_v_func.function = (&__pyx_f_9beam_calc_aperture_im);
+
+  /* "beam_calc.pyx":101
+ *     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     func.function = &aperture_im
+ *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)             # <<<<<<<<<<<<<<
+ *     return re + 1j * im
+ * 
+ */
+  __pyx_v_im = __pyx_f_9beam_calc_gsl_quad(__pyx_v_func, ((-__pyx_v_ap) / 2.0), (__pyx_v_ap / 2.0), 1e-9, 1e-7, (0x3E8 * __pyx_v_fn));
+
+  /* "beam_calc.pyx":102
+ *     func.function = &aperture_im
+ *     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
+ *     return re + 1j * im             # <<<<<<<<<<<<<<
  * 
  * def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):
  */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 186, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_wf, 2, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 186, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(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_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 186, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_5;
-  __pyx_t_5 = 0;
+  __pyx_t_1 = __pyx_t_double_complex_from_parts(0, 1.0);
+  __pyx_t_2 = __Pyx_c_sum_npy_float64(__pyx_t_npy_float64_complex_from_parts(__pyx_v_re, 0), __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_1), __Pyx_CIMAG(__pyx_t_1)), __pyx_t_npy_float64_complex_from_parts(__pyx_v_im, 0)));
+  __pyx_r = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_2), __Pyx_CIMAG(__pyx_t_2));
   goto __pyx_L0;
 
-  /* "beam_calc.pyx":171
- *     return np.asarray(wf)
+  /* "beam_calc.pyx":91
+ *     return sin(pi / wl / z * (x - xx)**2)
  * 
- * def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
- *     """
- *     1D Fresnel diffraction calculation for an array of wavefronts (without the coefficient)
+ * cdef complex_t aperture_wp(float_t x, float_t z, float_t wl, float_t ap) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         float_t re, im
  */
 
   /* 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_6, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
-  __Pyx_AddTraceback("beam_calc.fresnel_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
   __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wf0, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_xx_arr, 1);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":188
- *     return np.asarray(wf)
+/* "beam_calc.pyx":104
+ *     return re + 1j * im
  * 
  * def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):             # <<<<<<<<<<<<<<
  *     """
@@ -5508,14 +4059,17 @@ __pyx_f_9beam_calc_fnl_1d(__pyx_t_10, __pyx_t_11, __pyx_v_x_arr, __pyx_v_xx_arr,
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_9aperture(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_8aperture[] = "\n    Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)\n\n    x_arr - coordinates at the plane downstream [um]\n    z - propagation distance [um]\n    wl - wavelength [um]\n    ap - aperture's size [um]\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_9aperture = {"aperture", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_9aperture, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_8aperture};
-static PyObject *__pyx_pw_9beam_calc_9aperture(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_9beam_calc_3aperture(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_2aperture[] = "\n    Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)\n\n    x_arr - coordinates at the plane downstream [um]\n    z - propagation distance [um]\n    wl - wavelength [um]\n    ap - aperture's size [um]\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_3aperture = {"aperture", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_3aperture, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_2aperture};
+static PyObject *__pyx_pw_9beam_calc_3aperture(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
   __pyx_t_9beam_calc_float_t __pyx_v_z;
   __pyx_t_9beam_calc_float_t __pyx_v_wl;
   __pyx_t_9beam_calc_float_t __pyx_v_ap;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("aperture (wrapper)", 0);
@@ -5546,23 +4100,23 @@ static PyObject *__pyx_pw_9beam_calc_9aperture(PyObject *__pyx_self, PyObject *_
         case  1:
         if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_z)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("aperture", 1, 4, 4, 1); __PYX_ERR(0, 188, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("aperture", 1, 4, 4, 1); __PYX_ERR(0, 104, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("aperture", 1, 4, 4, 2); __PYX_ERR(0, 188, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("aperture", 1, 4, 4, 2); __PYX_ERR(0, 104, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
         if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ap)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("aperture", 1, 4, 4, 3); __PYX_ERR(0, 188, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("aperture", 1, 4, 4, 3); __PYX_ERR(0, 104, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "aperture") < 0)) __PYX_ERR(0, 188, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "aperture") < 0)) __PYX_ERR(0, 104, __pyx_L3_error)
       }
     } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
       goto __pyx_L5_argtuple_error;
@@ -5572,27 +4126,27 @@ static PyObject *__pyx_pw_9beam_calc_9aperture(PyObject *__pyx_self, PyObject *_
       values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
       values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
     }
-    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 188, __pyx_L3_error)
-    __pyx_v_z = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_z == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L3_error)
-    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L3_error)
-    __pyx_v_ap = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ap == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L3_error)
+    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 104, __pyx_L3_error)
+    __pyx_v_z = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_z == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error)
+    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error)
+    __pyx_v_ap = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ap == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("aperture", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 188, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("aperture", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 104, __pyx_L3_error)
   __pyx_L3_error:;
   __Pyx_AddTraceback("beam_calc.aperture", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_8aperture(__pyx_self, __pyx_v_x_arr, __pyx_v_z, __pyx_v_wl, __pyx_v_ap);
+  __pyx_r = __pyx_pf_9beam_calc_2aperture(__pyx_self, __pyx_v_x_arr, __pyx_v_z, __pyx_v_wl, __pyx_v_ap);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_9beam_calc_8aperture(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_z, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap) {
+static PyObject *__pyx_pf_9beam_calc_2aperture(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_z, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap) {
   __pyx_t_9beam_calc_int_t __pyx_v_a;
   __pyx_t_9beam_calc_int_t __pyx_v_i;
   __Pyx_memviewslice __pyx_v_wave_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
@@ -5610,9 +4164,12 @@ static PyObject *__pyx_pf_9beam_calc_8aperture(CYTHON_UNUSED PyObject *__pyx_sel
   int __pyx_t_10;
   __pyx_t_9beam_calc_int_t __pyx_t_11;
   __pyx_t_9beam_calc_int_t __pyx_t_12;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("aperture", 0);
 
-  /* "beam_calc.pyx":198
+  /* "beam_calc.pyx":114
  *     """
  *     cdef:
  *         int_t a = x_arr.shape[0], i             # <<<<<<<<<<<<<<
@@ -5621,51 +4178,51 @@ static PyObject *__pyx_pf_9beam_calc_8aperture(CYTHON_UNUSED PyObject *__pyx_sel
  */
   __pyx_v_a = (__pyx_v_x_arr.shape[0]);
 
-  /* "beam_calc.pyx":199
+  /* "beam_calc.pyx":115
  *     cdef:
  *         int_t a = x_arr.shape[0], i
  *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)             # <<<<<<<<<<<<<<
  *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
  *         wave_arr[i] = aperture_wp(x_arr[i], z, wl, ap)
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_1);
   PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
   __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_GIVEREF(__pyx_t_3);
   PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
   __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 199, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_v_wave_arr = __pyx_t_6;
   __pyx_t_6.memview = NULL;
   __pyx_t_6.data = NULL;
 
-  /* "beam_calc.pyx":200
+  /* "beam_calc.pyx":116
  *         int_t a = x_arr.shape[0], i
  *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
  *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):             # <<<<<<<<<<<<<<
@@ -5703,7 +4260,7 @@ static PyObject *__pyx_pf_9beam_calc_8aperture(CYTHON_UNUSED PyObject *__pyx_sel
                         {
                             __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
 
-                            /* "beam_calc.pyx":201
+                            /* "beam_calc.pyx":117
  *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
  *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
  *         wave_arr[i] = aperture_wp(x_arr[i], z, wl, ap)             # <<<<<<<<<<<<<<
@@ -5726,7 +4283,7 @@ static PyObject *__pyx_pf_9beam_calc_8aperture(CYTHON_UNUSED PyObject *__pyx_sel
         #endif
       }
 
-      /* "beam_calc.pyx":200
+      /* "beam_calc.pyx":116
  *         int_t a = x_arr.shape[0], i
  *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
  *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):             # <<<<<<<<<<<<<<
@@ -5745,20 +4302,20 @@ static PyObject *__pyx_pf_9beam_calc_8aperture(CYTHON_UNUSED PyObject *__pyx_sel
       }
   }
 
-  /* "beam_calc.pyx":202
+  /* "beam_calc.pyx":118
  *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
  *         wave_arr[i] = aperture_wp(x_arr[i], z, wl, ap)
  *     return np.asarray(wave_arr)             # <<<<<<<<<<<<<<
  * 
- * def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,
+ * cdef complex_t fhf_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_wave_arr, 1, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_wave_arr, 1, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -5770,73 +4327,292 @@ static PyObject *__pyx_pf_9beam_calc_8aperture(CYTHON_UNUSED PyObject *__pyx_sel
       __Pyx_DECREF_SET(__pyx_t_1, function);
     }
   }
-  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 202, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_5;
-  __pyx_t_5 = 0;
-  goto __pyx_L0;
+  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "beam_calc.pyx":104
+ *     return re + 1j * im
+ * 
+ * def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):             # <<<<<<<<<<<<<<
+ *     """
+ *     Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)
+ */
+
+  /* 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_6, 1);
+  __Pyx_AddTraceback("beam_calc.aperture", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wave_arr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":120
+ *     return np.asarray(wave_arr)
+ * 
+ * cdef complex_t fhf_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t a = wf0.shape[0], i
+ */
+
+static __pyx_t_double_complex __pyx_f_9beam_calc_fhf_wp(__Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_xx, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
+  __pyx_t_9beam_calc_int_t __pyx_v_a;
+  __pyx_t_9beam_calc_int_t __pyx_v_i;
+  __pyx_t_9beam_calc_float_t __pyx_v_ph0;
+  __pyx_t_9beam_calc_float_t __pyx_v_ph1;
+  __pyx_t_9beam_calc_float_t __pyx_v_ph;
+  __pyx_t_double_complex __pyx_v_wf;
+  __pyx_t_double_complex __pyx_r;
+  Py_ssize_t __pyx_t_1;
+  Py_ssize_t __pyx_t_2;
+  __pyx_t_double_complex __pyx_t_3;
+  __pyx_t_npy_float64_complex __pyx_t_4;
+  __pyx_t_9beam_calc_int_t __pyx_t_5;
+  __pyx_t_9beam_calc_int_t __pyx_t_6;
+  __pyx_t_9beam_calc_int_t __pyx_t_7;
+  __pyx_t_9beam_calc_int_t __pyx_t_8;
+  __pyx_t_9beam_calc_int_t __pyx_t_9;
+
+  /* "beam_calc.pyx":122
+ * cdef complex_t fhf_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
+ *     cdef:
+ *         int_t a = wf0.shape[0], i             # <<<<<<<<<<<<<<
+ *         float_t ph0, ph1, ph = pi / wl / dist * xx**2
+ *         complex_t wf = 0 + 0j
+ */
+  __pyx_v_a = (__pyx_v_wf0.shape[0]);
+
+  /* "beam_calc.pyx":123
+ *     cdef:
+ *         int_t a = wf0.shape[0], i
+ *         float_t ph0, ph1, ph = pi / wl / dist * xx**2             # <<<<<<<<<<<<<<
+ *         complex_t wf = 0 + 0j
+ *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx
+ */
+  __pyx_v_ph = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_dist) * pow(__pyx_v_xx, 2.0));
+
+  /* "beam_calc.pyx":124
+ *         int_t a = wf0.shape[0], i
+ *         float_t ph0, ph1, ph = pi / wl / dist * xx**2
+ *         complex_t wf = 0 + 0j             # <<<<<<<<<<<<<<
+ *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx
+ *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx
+ */
+  __pyx_v_wf = __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(0, 0), __pyx_t_double_complex_from_parts(0, 0.0));
+
+  /* "beam_calc.pyx":125
+ *         float_t ph0, ph1, ph = pi / wl / dist * xx**2
+ *         complex_t wf = 0 + 0j
+ *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx             # <<<<<<<<<<<<<<
+ *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx
+ *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
+ */
+  __pyx_t_1 = 0;
+  __pyx_v_ph0 = ((((((__pyx_t_9beam_calc_float_t)(2.0 * M_PI)) / __pyx_v_wl) / __pyx_v_dist) * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_1)) )))) * __pyx_v_xx);
+
+  /* "beam_calc.pyx":126
+ *         complex_t wf = 0 + 0j
+ *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx
+ *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx             # <<<<<<<<<<<<<<
+ *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
+ *     for i in range(2, a):
+ */
+  __pyx_t_1 = 1;
+  __pyx_v_ph1 = ((((((__pyx_t_9beam_calc_float_t)(2.0 * M_PI)) / __pyx_v_wl) / __pyx_v_dist) * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_1)) )))) * __pyx_v_xx);
+
+  /* "beam_calc.pyx":127
+ *     ph0 = 2 * pi / wl / dist * x_arr[0] * xx
+ *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx
+ *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])             # <<<<<<<<<<<<<<
+ *     for i in range(2, a):
+ *         ph0 = ph1
+ */
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 1;
+  __pyx_t_3 = __Pyx_c_quot_double(__Pyx_c_sum_double(__Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_1)) ))), __Pyx_c_diff_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph0), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph0), 0)))), __Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_2)) ))), __Pyx_c_diff_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph1), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph1), 0))))), __pyx_t_double_complex_from_parts(2, 0));
+  __pyx_t_2 = 1;
+  __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_3), __Pyx_CIMAG(__pyx_t_3)), __pyx_t_npy_float64_complex_from_parts(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_2)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_1)) )))), 0));
+  __pyx_v_wf = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_4), __Pyx_CIMAG(__pyx_t_4));
+
+  /* "beam_calc.pyx":128
+ *     ph1 = 2 * pi / wl / dist * x_arr[1] * xx
+ *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
+ *     for i in range(2, a):             # <<<<<<<<<<<<<<
+ *         ph0 = ph1
+ *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx
+ */
+  __pyx_t_5 = __pyx_v_a;
+  __pyx_t_6 = __pyx_t_5;
+  for (__pyx_t_7 = 2; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
+
+    /* "beam_calc.pyx":129
+ *     wf = (wf0[0] * (cos(ph0) - 1j * sin(ph0)) + wf0[1] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
+ *     for i in range(2, a):
+ *         ph0 = ph1             # <<<<<<<<<<<<<<
+ *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx
+ *         wf += (wf0[i - 1] * (cos(ph0) - 1j * sin(ph0)) + wf0[i] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
+ */
+    __pyx_v_ph0 = __pyx_v_ph1;
+
+    /* "beam_calc.pyx":130
+ *     for i in range(2, a):
+ *         ph0 = ph1
+ *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx             # <<<<<<<<<<<<<<
+ *         wf += (wf0[i - 1] * (cos(ph0) - 1j * sin(ph0)) + wf0[i] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
+ *     return wf * (cos(ph) + 1j * sin(ph))
+ */
+    __pyx_t_8 = __pyx_v_i;
+    __pyx_v_ph1 = ((((((__pyx_t_9beam_calc_float_t)(2.0 * M_PI)) / __pyx_v_wl) / __pyx_v_dist) * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_8)) )))) * __pyx_v_xx);
+
+    /* "beam_calc.pyx":131
+ *         ph0 = ph1
+ *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx
+ *         wf += (wf0[i - 1] * (cos(ph0) - 1j * sin(ph0)) + wf0[i] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])             # <<<<<<<<<<<<<<
+ *     return wf * (cos(ph) + 1j * sin(ph))
+ * 
+ */
+    __pyx_t_8 = (__pyx_v_i - 1);
+    __pyx_t_9 = __pyx_v_i;
+    __pyx_t_3 = __Pyx_c_quot_double(__Pyx_c_sum_double(__Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_8)) ))), __Pyx_c_diff_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph0), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph0), 0)))), __Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_9)) ))), __Pyx_c_diff_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph1), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph1), 0))))), __pyx_t_double_complex_from_parts(2, 0));
+    __pyx_t_9 = __pyx_v_i;
+    __pyx_t_8 = (__pyx_v_i - 1);
+    __pyx_t_4 = __Pyx_c_sum_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_v_wf), __Pyx_CIMAG(__pyx_v_wf)), __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_3), __Pyx_CIMAG(__pyx_t_3)), __pyx_t_npy_float64_complex_from_parts(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_9)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_8)) )))), 0)));
+    __pyx_v_wf = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_4), __Pyx_CIMAG(__pyx_t_4));
+  }
+
+  /* "beam_calc.pyx":132
+ *         ph1 = 2 * pi / wl / dist * x_arr[i] * xx
+ *         wf += (wf0[i - 1] * (cos(ph0) - 1j * sin(ph0)) + wf0[i] * (cos(ph1) - 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
+ *     return wf * (cos(ph) + 1j * sin(ph))             # <<<<<<<<<<<<<<
+ * 
+ * cdef void fhf_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
+ */
+  __pyx_r = __Pyx_c_prod_double(__pyx_v_wf, __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph), 0))));
+  goto __pyx_L0;
+
+  /* "beam_calc.pyx":120
+ *     return np.asarray(wave_arr)
+ * 
+ * cdef complex_t fhf_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t a = wf0.shape[0], i
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":134
+ *     return wf * (cos(ph) + 1j * sin(ph))
+ * 
+ * cdef void fhf_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t a = xx_arr.shape[0], i
+ */
+
+static void __pyx_f_9beam_calc_fhf_1d(__Pyx_memviewslice __pyx_v_wf1, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
+  __pyx_t_9beam_calc_int_t __pyx_v_a;
+  __pyx_t_9beam_calc_int_t __pyx_v_i;
+  __pyx_t_9beam_calc_int_t __pyx_t_1;
+  __pyx_t_9beam_calc_int_t __pyx_t_2;
+  __pyx_t_9beam_calc_int_t __pyx_t_3;
+  __pyx_t_9beam_calc_int_t __pyx_t_4;
+  __pyx_t_9beam_calc_int_t __pyx_t_5;
+
+  /* "beam_calc.pyx":136
+ * cdef void fhf_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
+ *     cdef:
+ *         int_t a = xx_arr.shape[0], i             # <<<<<<<<<<<<<<
+ *     for i in range(a):
+ *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
+ */
+  __pyx_v_a = (__pyx_v_xx_arr.shape[0]);
+
+  /* "beam_calc.pyx":137
+ *     cdef:
+ *         int_t a = xx_arr.shape[0], i
+ *     for i in range(a):             # <<<<<<<<<<<<<<
+ *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
+ * 
+ */
+  __pyx_t_1 = __pyx_v_a;
+  __pyx_t_2 = __pyx_t_1;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+
+    /* "beam_calc.pyx":138
+ *         int_t a = xx_arr.shape[0], i
+ *     for i in range(a):
+ *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)             # <<<<<<<<<<<<<<
+ * 
+ * def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
+ */
+    __pyx_t_4 = __pyx_v_i;
+    __pyx_t_5 = __pyx_v_i;
+    *((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf1.data) + __pyx_t_5)) )) = __pyx_f_9beam_calc_fhf_wp(__pyx_v_wf0, __pyx_v_x_arr, (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_xx_arr.data) + __pyx_t_4)) ))), __pyx_v_dist, __pyx_v_wl);
+  }
 
-  /* "beam_calc.pyx":188
- *     return np.asarray(wf)
+  /* "beam_calc.pyx":134
+ *     return wf * (cos(ph) + 1j * sin(ph))
  * 
- * def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):             # <<<<<<<<<<<<<<
- *     """
- *     Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)
+ * cdef void fhf_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t a = xx_arr.shape[0], i
  */
 
   /* 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_6, 1);
-  __Pyx_AddTraceback("beam_calc.aperture", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wave_arr, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
 }
 
-/* "beam_calc.pyx":204
- *     return np.asarray(wave_arr)
+/* "beam_calc.pyx":140
+ *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
  * 
- * def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,             # <<<<<<<<<<<<<<
- *          float_t defoc, float_t alpha):
+ * def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
+ *     1D Fraunhofer diffraction calculation (without the coefficient)
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_11lens(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_10lens[] = "\n    Lens wavefront calculation by dint of Fresnel diffraction (without the coefficient)\n    with third order polinomial abberations\n\n    x_arr - coordinates at the plane downstream [um]\n    wl - wavelength [um]\n    ap - lens' size [um]\n    focus - focal distance [um]\n    defoc - defocus [um]\n    alpha - abberations coefficient [rad/mrad^3]\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_11lens = {"lens", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_11lens, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_10lens};
-static PyObject *__pyx_pw_9beam_calc_11lens(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_9beam_calc_5fraunhofer_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_4fraunhofer_1d[] = "\n    1D Fraunhofer diffraction calculation (without the coefficient)\n\n    wf0 - wavefront at the plane downstream\n    x_arr - coordinates at the plane downstream [um]\n    xx_arr - coordinates at the plane upstream [um]\n    dist - distance between planes [um]\n    wl - wavelength [um]\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_5fraunhofer_1d = {"fraunhofer_1d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_5fraunhofer_1d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_4fraunhofer_1d};
+static PyObject *__pyx_pw_9beam_calc_5fraunhofer_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __Pyx_memviewslice __pyx_v_wf0 = { 0, 0, { 0 }, { 0 }, { 0 } };
   __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_xx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_float_t __pyx_v_dist;
   __pyx_t_9beam_calc_float_t __pyx_v_wl;
-  __pyx_t_9beam_calc_float_t __pyx_v_ap;
-  __pyx_t_9beam_calc_float_t __pyx_v_focus;
-  __pyx_t_9beam_calc_float_t __pyx_v_defoc;
-  __pyx_t_9beam_calc_float_t __pyx_v_alpha;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("lens (wrapper)", 0);
+  __Pyx_RefNannySetupContext("fraunhofer_1d (wrapper)", 0);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_arr,&__pyx_n_s_wl,&__pyx_n_s_ap,&__pyx_n_s_focus,&__pyx_n_s_defoc,&__pyx_n_s_alpha,0};
-    PyObject* values[6] = {0,0,0,0,0,0};
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_wf0,&__pyx_n_s_x_arr,&__pyx_n_s_xx_arr,&__pyx_n_s_dist,&__pyx_n_s_wl,0};
+    PyObject* values[5] = {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  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);
@@ -5853,43 +4629,37 @@ static PyObject *__pyx_pw_9beam_calc_11lens(PyObject *__pyx_self, PyObject *__py
       kw_args = PyDict_Size(__pyx_kwds);
       switch (pos_args) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_arr)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wf0)) != 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_wl)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_arr)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("lens", 1, 6, 6, 1); __PYX_ERR(0, 204, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, 1); __PYX_ERR(0, 140, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ap)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xx_arr)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("lens", 1, 6, 6, 2); __PYX_ERR(0, 204, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, 2); __PYX_ERR(0, 140, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_focus)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("lens", 1, 6, 6, 3); __PYX_ERR(0, 204, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, 3); __PYX_ERR(0, 140, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defoc)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("lens", 1, 6, 6, 4); __PYX_ERR(0, 204, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("lens", 1, 6, 6, 5); __PYX_ERR(0, 204, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, 4); __PYX_ERR(0, 140, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "lens") < 0)) __PYX_ERR(0, 204, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fraunhofer_1d") < 0)) __PYX_ERR(0, 140, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 6) {
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
       goto __pyx_L5_argtuple_error;
     } else {
       values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
@@ -5897,34 +4667,31 @@ static PyObject *__pyx_pw_9beam_calc_11lens(PyObject *__pyx_self, PyObject *__py
       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);
     }
-    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 204, __pyx_L3_error)
-    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
-    __pyx_v_ap = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ap == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
-    __pyx_v_focus = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_focus == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
-    __pyx_v_defoc = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_defoc == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 205, __pyx_L3_error)
-    __pyx_v_alpha = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_alpha == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 205, __pyx_L3_error)
+    __pyx_v_wf0 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_wf0.memview)) __PYX_ERR(0, 140, __pyx_L3_error)
+    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 140, __pyx_L3_error)
+    __pyx_v_xx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_xx_arr.memview)) __PYX_ERR(0, 140, __pyx_L3_error)
+    __pyx_v_dist = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_dist == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 140, __pyx_L3_error)
+    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 140, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("lens", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 204, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("fraunhofer_1d", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 140, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("beam_calc.lens", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("beam_calc.fraunhofer_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_10lens(__pyx_self, __pyx_v_x_arr, __pyx_v_wl, __pyx_v_ap, __pyx_v_focus, __pyx_v_defoc, __pyx_v_alpha);
+  __pyx_r = __pyx_pf_9beam_calc_4fraunhofer_1d(__pyx_self, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_9beam_calc_10lens(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_wl, __pyx_t_9beam_calc_float_t __pyx_v_ap, __pyx_t_9beam_calc_float_t __pyx_v_focus, __pyx_t_9beam_calc_float_t __pyx_v_defoc, __pyx_t_9beam_calc_float_t __pyx_v_alpha) {
+static PyObject *__pyx_pf_9beam_calc_4fraunhofer_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
   __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __Pyx_memviewslice __pyx_v_wave_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
@@ -5933,161 +4700,87 @@ static PyObject *__pyx_pf_9beam_calc_10lens(CYTHON_UNUSED PyObject *__pyx_self,
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
   __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_int_t __pyx_t_7;
-  __pyx_t_9beam_calc_int_t __pyx_t_8;
-  __pyx_t_9beam_calc_int_t __pyx_t_9;
-  int __pyx_t_10;
-  __pyx_t_9beam_calc_int_t __pyx_t_11;
-  __pyx_t_9beam_calc_int_t __pyx_t_12;
-  __Pyx_RefNannySetupContext("lens", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("fraunhofer_1d", 0);
 
-  /* "beam_calc.pyx":218
+  /* "beam_calc.pyx":151
  *     """
  *     cdef:
- *         int_t a = x_arr.shape[0], i             # <<<<<<<<<<<<<<
- *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
+ *         int_t a = xx_arr.shape[0]             # <<<<<<<<<<<<<<
+ *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
+ *     fhf_1d(wf, wf0, x_arr, xx_arr, dist, wl)
  */
-  __pyx_v_a = (__pyx_v_x_arr.shape[0]);
+  __pyx_v_a = (__pyx_v_xx_arr.shape[0]);
 
-  /* "beam_calc.pyx":219
+  /* "beam_calc.pyx":152
  *     cdef:
- *         int_t a = x_arr.shape[0], i
- *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)             # <<<<<<<<<<<<<<
- *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
- *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha)
+ *         int_t a = xx_arr.shape[0]
+ *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)             # <<<<<<<<<<<<<<
+ *     fhf_1d(wf, wf0, x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_1);
   PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
   __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_GIVEREF(__pyx_t_3);
   PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
   __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 219, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_wave_arr = __pyx_t_6;
+  __pyx_v_wf = __pyx_t_6;
   __pyx_t_6.memview = NULL;
   __pyx_t_6.data = NULL;
 
-  /* "beam_calc.pyx":220
- *         int_t a = x_arr.shape[0], i
- *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):             # <<<<<<<<<<<<<<
- *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha)
- *     return np.asarray(wave_arr)
- */
-  {
-      #ifdef WITH_THREAD
-      PyThreadState *_save;
-      Py_UNBLOCK_THREADS
-      __Pyx_FastGIL_Remember();
-      #endif
-      /*try:*/ {
-        __pyx_t_7 = __pyx_v_a;
-        if ((1 == 0)) abort();
-        {
-            __pyx_t_10 = 10;
-            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
-                #undef likely
-                #undef unlikely
-                #define likely(x)   (x)
-                #define unlikely(x) (x)
-            #endif
-            __pyx_t_9 = (__pyx_t_7 - 0 + 1 - 1/abs(1)) / 1;
-            if (__pyx_t_9 > 0)
-            {
-                #ifdef _OPENMP
-                #pragma omp parallel private(__pyx_t_11, __pyx_t_12)
-                #endif /* _OPENMP */
-                {
-                    #ifdef _OPENMP
-                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) schedule(guided, __pyx_t_10)
-                    #endif /* _OPENMP */
-                    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
-                        {
-                            __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
-
-                            /* "beam_calc.pyx":221
- *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
- *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha)             # <<<<<<<<<<<<<<
- *     return np.asarray(wave_arr)
+  /* "beam_calc.pyx":153
+ *         int_t a = xx_arr.shape[0]
+ *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
+ *     fhf_1d(wf, wf0, x_arr, xx_arr, dist, wl)             # <<<<<<<<<<<<<<
+ *     return np.asarray(wf)
  * 
  */
-                            __pyx_t_11 = __pyx_v_i;
-                            __pyx_t_12 = __pyx_v_i;
-                            *((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wave_arr.data) + __pyx_t_12)) )) = __pyx_f_9beam_calc_lens_wp((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_11)) ))), __pyx_v_wl, __pyx_v_ap, __pyx_v_focus, __pyx_v_defoc, __pyx_v_alpha);
-                        }
-                    }
-                }
-            }
-        }
-        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
-            #undef likely
-            #undef unlikely
-            #define likely(x)   __builtin_expect(!!(x), 1)
-            #define unlikely(x) __builtin_expect(!!(x), 0)
-        #endif
-      }
-
-      /* "beam_calc.pyx":220
- *         int_t a = x_arr.shape[0], i
- *         complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
- *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):             # <<<<<<<<<<<<<<
- *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha)
- *     return np.asarray(wave_arr)
- */
-      /*finally:*/ {
-        /*normal exit:*/{
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L5;
-        }
-        __pyx_L5:;
-      }
-  }
+  __pyx_f_9beam_calc_fhf_1d(__pyx_v_wf, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
 
-  /* "beam_calc.pyx":222
- *     for i in prange(a, schedule='guided', nogil=True, chunksize=10):
- *         wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha)
- *     return np.asarray(wave_arr)             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":154
+ *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
+ *     fhf_1d(wf, wf0, x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)             # <<<<<<<<<<<<<<
  * 
- * def barcode_steps(float_t bm_dx, float_t br_dx, float_t rd, float_t ss, int_t nf):
+ * def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_wave_arr, 1, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_wf, 1, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -6102,19 +4795,19 @@ static PyObject *__pyx_pf_9beam_calc_10lens(CYTHON_UNUSED PyObject *__pyx_self,
   __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error)
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_r = __pyx_t_5;
   __pyx_t_5 = 0;
   goto __pyx_L0;
 
-  /* "beam_calc.pyx":204
- *     return np.asarray(wave_arr)
+  /* "beam_calc.pyx":140
+ *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
  * 
- * def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,             # <<<<<<<<<<<<<<
- *          float_t defoc, float_t alpha):
+ * def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
+ *     1D Fraunhofer diffraction calculation (without the coefficient)
  */
 
   /* function exit code */
@@ -6125,39 +4818,44 @@ static PyObject *__pyx_pf_9beam_calc_10lens(CYTHON_UNUSED PyObject *__pyx_self,
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
   __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
-  __Pyx_AddTraceback("beam_calc.lens", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("beam_calc.fraunhofer_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wave_arr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wf0, 1);
   __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_xx_arr, 1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":224
- *     return np.asarray(wave_arr)
+/* "beam_calc.pyx":156
+ *     return np.asarray(wf)
  * 
- * def barcode_steps(float_t bm_dx, float_t br_dx, float_t rd, float_t ss, int_t nf):             # <<<<<<<<<<<<<<
+ * def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
- *     Barcode bars' coordinates generation with random deviation
+ *     1D Fraunhofer diffraction calculation for an array of wavefronts (without the coefficient)
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_13barcode_steps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_12barcode_steps[] = "\n    Barcode bars' coordinates generation with random deviation\n\n    bm_dx - incident beam size [um]\n    br_dx - mean bar size [um]\n    rd - random deviation (0.0 - 1.0)\n    ss - scan step size [um]\n    nf - number of frames of a scan\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_13barcode_steps = {"barcode_steps", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_13barcode_steps, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_12barcode_steps};
-static PyObject *__pyx_pw_9beam_calc_13barcode_steps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  __pyx_t_9beam_calc_float_t __pyx_v_bm_dx;
-  __pyx_t_9beam_calc_float_t __pyx_v_br_dx;
-  __pyx_t_9beam_calc_float_t __pyx_v_rd;
-  __pyx_t_9beam_calc_float_t __pyx_v_ss;
-  __pyx_t_9beam_calc_int_t __pyx_v_nf;
+static PyObject *__pyx_pw_9beam_calc_7fraunhofer_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_6fraunhofer_2d[] = "\n    1D Fraunhofer diffraction calculation for an array of wavefronts (without the coefficient)\n\n    wf0 - an array of wavefronts at the plane downstream\n    x_arr - coordinates at the plane downstream [um]\n    xx_arr - coordinates at the plane upstream [um]\n    dist - distance between planes [um]\n    wl - wavelength [um]\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_7fraunhofer_2d = {"fraunhofer_2d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_7fraunhofer_2d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_6fraunhofer_2d};
+static PyObject *__pyx_pw_9beam_calc_7fraunhofer_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __Pyx_memviewslice __pyx_v_wf0 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_xx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_float_t __pyx_v_dist;
+  __pyx_t_9beam_calc_float_t __pyx_v_wl;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("barcode_steps (wrapper)", 0);
+  __Pyx_RefNannySetupContext("fraunhofer_2d (wrapper)", 0);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bm_dx,&__pyx_n_s_br_dx,&__pyx_n_s_rd,&__pyx_n_s_ss,&__pyx_n_s_nf,0};
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_wf0,&__pyx_n_s_x_arr,&__pyx_n_s_xx_arr,&__pyx_n_s_dist,&__pyx_n_s_wl,0};
     PyObject* values[5] = {0,0,0,0,0};
     if (unlikely(__pyx_kwds)) {
       Py_ssize_t kw_args;
@@ -6179,35 +4877,35 @@ static PyObject *__pyx_pw_9beam_calc_13barcode_steps(PyObject *__pyx_self, PyObj
       kw_args = PyDict_Size(__pyx_kwds);
       switch (pos_args) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bm_dx)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wf0)) != 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_br_dx)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_arr)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("barcode_steps", 1, 5, 5, 1); __PYX_ERR(0, 224, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, 1); __PYX_ERR(0, 156, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rd)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xx_arr)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("barcode_steps", 1, 5, 5, 2); __PYX_ERR(0, 224, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, 2); __PYX_ERR(0, 156, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ss)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("barcode_steps", 1, 5, 5, 3); __PYX_ERR(0, 224, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, 3); __PYX_ERR(0, 156, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nf)) != 0)) kw_args--;
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("barcode_steps", 1, 5, 5, 4); __PYX_ERR(0, 224, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, 4); __PYX_ERR(0, 156, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "barcode_steps") < 0)) __PYX_ERR(0, 224, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fraunhofer_2d") < 0)) __PYX_ERR(0, 156, __pyx_L3_error)
       }
     } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
       goto __pyx_L5_argtuple_error;
@@ -6218,494 +4916,415 @@ static PyObject *__pyx_pw_9beam_calc_13barcode_steps(PyObject *__pyx_self, PyObj
       values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
       values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
     }
-    __pyx_v_bm_dx = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_bm_dx == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 224, __pyx_L3_error)
-    __pyx_v_br_dx = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_br_dx == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 224, __pyx_L3_error)
-    __pyx_v_rd = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_rd == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 224, __pyx_L3_error)
-    __pyx_v_ss = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ss == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 224, __pyx_L3_error)
-    __pyx_v_nf = __Pyx_PyInt_As_npy_int64(values[4]); if (unlikely((__pyx_v_nf == ((npy_int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 224, __pyx_L3_error)
+    __pyx_v_wf0 = __Pyx_PyObject_to_MemoryviewSlice_d_dc___pyx_t_double_complex(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_wf0.memview)) __PYX_ERR(0, 156, __pyx_L3_error)
+    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 156, __pyx_L3_error)
+    __pyx_v_xx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_xx_arr.memview)) __PYX_ERR(0, 156, __pyx_L3_error)
+    __pyx_v_dist = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_dist == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 156, __pyx_L3_error)
+    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 156, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("barcode_steps", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 224, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("fraunhofer_2d", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 156, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("beam_calc.barcode_steps", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("beam_calc.fraunhofer_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_12barcode_steps(__pyx_self, __pyx_v_bm_dx, __pyx_v_br_dx, __pyx_v_rd, __pyx_v_ss, __pyx_v_nf);
+  __pyx_r = __pyx_pf_9beam_calc_6fraunhofer_2d(__pyx_self, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_9beam_calc_12barcode_steps(CYTHON_UNUSED PyObject *__pyx_self, __pyx_t_9beam_calc_float_t __pyx_v_bm_dx, __pyx_t_9beam_calc_float_t __pyx_v_br_dx, __pyx_t_9beam_calc_float_t __pyx_v_rd, __pyx_t_9beam_calc_float_t __pyx_v_ss, __pyx_t_9beam_calc_int_t __pyx_v_nf) {
-  __pyx_t_9beam_calc_int_t __pyx_v_br_n;
+static PyObject *__pyx_pf_9beam_calc_6fraunhofer_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
+  __pyx_t_9beam_calc_int_t __pyx_v_a;
+  __pyx_t_9beam_calc_int_t __pyx_v_b;
   __pyx_t_9beam_calc_int_t __pyx_v_i;
-  gsl_rng *__pyx_v_r;
-  __pyx_t_9beam_calc_float_t __pyx_v_bs_min;
-  __pyx_t_9beam_calc_float_t __pyx_v_bs_max;
-  __Pyx_memviewslice __pyx_v_bx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  long __pyx_t_1;
-  __pyx_t_9beam_calc_float_t __pyx_t_2;
-  __pyx_t_9beam_calc_float_t __pyx_t_3;
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  PyObject *__pyx_t_6 = NULL;
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *__pyx_t_8 = NULL;
-  __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  Py_ssize_t __pyx_t_10;
-  __pyx_t_9beam_calc_int_t __pyx_t_11;
-  __pyx_t_9beam_calc_int_t __pyx_t_12;
-  __pyx_t_9beam_calc_int_t __pyx_t_13;
-  __pyx_t_9beam_calc_int_t __pyx_t_14;
-  __pyx_t_9beam_calc_int_t __pyx_t_15;
-  __Pyx_RefNannySetupContext("barcode_steps", 0);
+  __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_int_t __pyx_t_7;
+  __pyx_t_9beam_calc_int_t __pyx_t_8;
+  __pyx_t_9beam_calc_int_t __pyx_t_9;
+  __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("fraunhofer_2d", 0);
 
-  /* "beam_calc.pyx":235
+  /* "beam_calc.pyx":167
  *     """
  *     cdef:
- *         int_t br_n = (<int_t>((bm_dx + ss * nf) / br_dx) // 2 + 1) * 2, i             # <<<<<<<<<<<<<<
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
- *         float_t bs_min = max(1 - rd, 0), bs_max = 1 + rd
+ *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i             # <<<<<<<<<<<<<<
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True):
  */
-  __pyx_v_br_n = (((((__pyx_t_9beam_calc_int_t)((__pyx_v_bm_dx + (__pyx_v_ss * __pyx_v_nf)) / __pyx_v_br_dx)) / 2) + 1) * 2);
+  __pyx_v_a = (__pyx_v_wf0.shape[0]);
+  __pyx_v_b = (__pyx_v_xx_arr.shape[0]);
 
-  /* "beam_calc.pyx":236
+  /* "beam_calc.pyx":168
  *     cdef:
- *         int_t br_n = (<int_t>((bm_dx + ss * nf) / br_dx) // 2 + 1) * 2, i
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)             # <<<<<<<<<<<<<<
- *         float_t bs_min = max(1 - rd, 0), bs_max = 1 + rd
- *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
- */
-  __pyx_v_r = gsl_rng_alloc(gsl_rng_mt19937);
-
-  /* "beam_calc.pyx":237
- *         int_t br_n = (<int_t>((bm_dx + ss * nf) / br_dx) // 2 + 1) * 2, i
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
- *         float_t bs_min = max(1 - rd, 0), bs_max = 1 + rd             # <<<<<<<<<<<<<<
- *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
- *     bx_arr[0] = br_dx * (0.5 + bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
- */
-  __pyx_t_1 = 0;
-  __pyx_t_2 = (1.0 - __pyx_v_rd);
-  if (((__pyx_t_1 > __pyx_t_2) != 0)) {
-    __pyx_t_3 = __pyx_t_1;
-  } else {
-    __pyx_t_3 = __pyx_t_2;
-  }
-  __pyx_v_bs_min = __pyx_t_3;
-  __pyx_v_bs_max = (1.0 + __pyx_v_rd);
-
-  /* "beam_calc.pyx":238
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
- *         float_t bs_min = max(1 - rd, 0), bs_max = 1 + rd
- *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)             # <<<<<<<<<<<<<<
- *     bx_arr[0] = br_dx * (0.5 + bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
- *     for i in range(1, br_n):
+ *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)             # <<<<<<<<<<<<<<
+ *     for i in prange(a, schedule='guided', nogil=True):
+ *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyInt_From_npy_int64(__pyx_v_br_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
   __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_7);
-  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float64); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_8);
-  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 168, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(__pyx_t_8, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __pyx_v_bx_arr = __pyx_t_9;
-  __pyx_t_9.memview = NULL;
-  __pyx_t_9.data = NULL;
-
-  /* "beam_calc.pyx":239
- *         float_t bs_min = max(1 - rd, 0), bs_max = 1 + rd
- *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
- *     bx_arr[0] = br_dx * (0.5 + bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))             # <<<<<<<<<<<<<<
- *     for i in range(1, br_n):
- *         bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
- */
-  __pyx_t_10 = 0;
-  *((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_10)) )) = (__pyx_v_br_dx * ((0.5 + __pyx_v_bs_min) + ((__pyx_v_bs_max - __pyx_v_bs_min) * gsl_rng_uniform_pos(__pyx_v_r))));
-
-  /* "beam_calc.pyx":240
- *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
- *     bx_arr[0] = br_dx * (0.5 + bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
- *     for i in range(1, br_n):             # <<<<<<<<<<<<<<
- *         bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
- *     return np.asarray(bx_arr)
- */
-  __pyx_t_11 = __pyx_v_br_n;
-  __pyx_t_12 = __pyx_t_11;
-  for (__pyx_t_13 = 1; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) {
-    __pyx_v_i = __pyx_t_13;
-
-    /* "beam_calc.pyx":241
- *     bx_arr[0] = br_dx * (0.5 + bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
- *     for i in range(1, br_n):
- *         bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))             # <<<<<<<<<<<<<<
- *     return np.asarray(bx_arr)
- * 
- */
-    __pyx_t_14 = (__pyx_v_i - 1);
-    __pyx_t_15 = __pyx_v_i;
-    *((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_15)) )) = ((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_14)) ))) + (__pyx_v_br_dx * (__pyx_v_bs_min + ((__pyx_v_bs_max - __pyx_v_bs_min) * gsl_rng_uniform_pos(__pyx_v_r)))));
-  }
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_wf = __pyx_t_6;
+  __pyx_t_6.memview = NULL;
+  __pyx_t_6.data = NULL;
 
-  /* "beam_calc.pyx":242
- *     for i in range(1, br_n):
- *         bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
- *     return np.asarray(bx_arr)             # <<<<<<<<<<<<<<
- * 
- * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:
+  /* "beam_calc.pyx":169
+ *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)
  */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 242, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_bx_arr, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_9beam_calc_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_9beam_calc_float_t, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
-    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
-    if (likely(__pyx_t_5)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
-      __Pyx_INCREF(__pyx_t_5);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_6, function);
-    }
-  }
-  __pyx_t_8 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_8);
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  __pyx_r = __pyx_t_8;
-  __pyx_t_8 = 0;
-  goto __pyx_L0;
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      __Pyx_FastGIL_Remember();
+      #endif
+      /*try:*/ {
+        __pyx_t_7 = __pyx_v_a;
+        if ((1 == 0)) abort();
+        {
+            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
+                #undef likely
+                #undef unlikely
+                #define likely(x)   (x)
+                #define unlikely(x) (x)
+            #endif
+            __pyx_t_9 = (__pyx_t_7 - 0 + 1 - 1/abs(1)) / 1;
+            if (__pyx_t_9 > 0)
+            {
+                #ifdef _OPENMP
+                #pragma omp parallel firstprivate(__pyx_t_10, __pyx_t_11)
+                #endif /* _OPENMP */
+                {
+                    #ifdef _OPENMP
+                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) schedule(guided)
+                    #endif /* _OPENMP */
+                    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
+                        {
+                            __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
 
-  /* "beam_calc.pyx":224
- *     return np.asarray(wave_arr)
+                            /* "beam_calc.pyx":170
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True):
+ *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)             # <<<<<<<<<<<<<<
+ *     return np.asarray(wf)
  * 
- * def barcode_steps(float_t bm_dx, float_t br_dx, float_t rd, float_t ss, int_t nf):             # <<<<<<<<<<<<<<
- *     """
- *     Barcode bars' coordinates generation with random deviation
  */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_8);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_9, 1);
-  __Pyx_AddTraceback("beam_calc.barcode_steps", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_bx_arr, 1);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
+                            __pyx_t_10.data = __pyx_v_wf.data;
+                            __pyx_t_10.memview = __pyx_v_wf.memview;
+                            __PYX_INC_MEMVIEW(&__pyx_t_10, 0);
+                            {
+    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_wf.strides[0];
+        __pyx_t_10.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
-/* "beam_calc.pyx":244
- *     return np.asarray(bx_arr)
- * 
- * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:             # <<<<<<<<<<<<<<
- *     cdef int_t m = l + (r - l) // 2
- *     if l <= r:
- */
-
-static __pyx_t_9beam_calc_int_t __pyx_f_9beam_calc_binary_search(__Pyx_memviewslice __pyx_v_values, __pyx_t_9beam_calc_int_t __pyx_v_l, __pyx_t_9beam_calc_int_t __pyx_v_r, __pyx_t_9beam_calc_float_t __pyx_v_x) {
-  __pyx_t_9beam_calc_int_t __pyx_v_m;
-  __pyx_t_9beam_calc_int_t __pyx_r;
-  int __pyx_t_1;
-  __pyx_t_9beam_calc_int_t __pyx_t_2;
-  __pyx_t_9beam_calc_int_t __pyx_t_3;
-  int __pyx_t_4;
-  __pyx_t_9beam_calc_int_t __pyx_t_5;
-  __pyx_t_9beam_calc_int_t __pyx_t_6;
-
-  /* "beam_calc.pyx":245
- * 
- * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:
- *     cdef int_t m = l + (r - l) // 2             # <<<<<<<<<<<<<<
- *     if l <= r:
- *         if x == values[m]:
- */
-  __pyx_v_m = (__pyx_v_l + ((__pyx_v_r - __pyx_v_l) / 2));
-
-  /* "beam_calc.pyx":246
- * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:
- *     cdef int_t m = l + (r - l) // 2
- *     if l <= r:             # <<<<<<<<<<<<<<
- *         if x == values[m]:
- *             return m
- */
-  __pyx_t_1 = ((__pyx_v_l <= __pyx_v_r) != 0);
-  if (__pyx_t_1) {
-
-    /* "beam_calc.pyx":247
- *     cdef int_t m = l + (r - l) // 2
- *     if l <= r:
- *         if x == values[m]:             # <<<<<<<<<<<<<<
- *             return m
- *         elif x > values[m] and x <= values[m + 1]:
- */
-    __pyx_t_2 = __pyx_v_m;
-    __pyx_t_1 = ((__pyx_v_x == (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_2)) )))) != 0);
-    if (__pyx_t_1) {
-
-      /* "beam_calc.pyx":248
- *     if l <= r:
- *         if x == values[m]:
- *             return m             # <<<<<<<<<<<<<<
- *         elif x > values[m] and x <= values[m + 1]:
- *             return m + 1
- */
-      __pyx_r = __pyx_v_m;
-      goto __pyx_L0;
-
-      /* "beam_calc.pyx":247
- *     cdef int_t m = l + (r - l) // 2
- *     if l <= r:
- *         if x == values[m]:             # <<<<<<<<<<<<<<
- *             return m
- *         elif x > values[m] and x <= values[m + 1]:
- */
-    }
-
-    /* "beam_calc.pyx":249
- *         if x == values[m]:
- *             return m
- *         elif x > values[m] and x <= values[m + 1]:             # <<<<<<<<<<<<<<
- *             return m + 1
- *         elif x < values[m]:
- */
-    __pyx_t_3 = __pyx_v_m;
-    __pyx_t_4 = ((__pyx_v_x > (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_3)) )))) != 0);
-    if (__pyx_t_4) {
-    } else {
-      __pyx_t_1 = __pyx_t_4;
-      goto __pyx_L5_bool_binop_done;
-    }
-    __pyx_t_5 = (__pyx_v_m + 1);
-    __pyx_t_4 = ((__pyx_v_x <= (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_5)) )))) != 0);
-    __pyx_t_1 = __pyx_t_4;
-    __pyx_L5_bool_binop_done:;
-    if (__pyx_t_1) {
-
-      /* "beam_calc.pyx":250
- *             return m
- *         elif x > values[m] and x <= values[m + 1]:
- *             return m + 1             # <<<<<<<<<<<<<<
- *         elif x < values[m]:
- *             return binary_search(values, l, m, x)
- */
-      __pyx_r = (__pyx_v_m + 1);
-      goto __pyx_L0;
+__pyx_t_10.shape[0] = __pyx_v_wf.shape[1];
+__pyx_t_10.strides[0] = __pyx_v_wf.strides[1];
+    __pyx_t_10.suboffsets[0] = -1;
 
-      /* "beam_calc.pyx":249
- *         if x == values[m]:
- *             return m
- *         elif x > values[m] and x <= values[m + 1]:             # <<<<<<<<<<<<<<
- *             return m + 1
- *         elif x < values[m]:
- */
-    }
+__pyx_t_11.data = __pyx_v_wf0.data;
+                            __pyx_t_11.memview = __pyx_v_wf0.memview;
+                            __PYX_INC_MEMVIEW(&__pyx_t_11, 0);
+                            {
+    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_wf0.strides[0];
+        __pyx_t_11.data += __pyx_tmp_idx * __pyx_tmp_stride;
+}
 
-    /* "beam_calc.pyx":251
- *         elif x > values[m] and x <= values[m + 1]:
- *             return m + 1
- *         elif x < values[m]:             # <<<<<<<<<<<<<<
- *             return binary_search(values, l, m, x)
- *         else:
- */
-    __pyx_t_6 = __pyx_v_m;
-    __pyx_t_1 = ((__pyx_v_x < (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_6)) )))) != 0);
-    if (__pyx_t_1) {
+__pyx_t_11.shape[0] = __pyx_v_wf0.shape[1];
+__pyx_t_11.strides[0] = __pyx_v_wf0.strides[1];
+    __pyx_t_11.suboffsets[0] = -1;
 
-      /* "beam_calc.pyx":252
- *             return m + 1
- *         elif x < values[m]:
- *             return binary_search(values, l, m, x)             # <<<<<<<<<<<<<<
- *         else:
- *             return binary_search(values, m + 1, r, x)
- */
-      __pyx_r = __pyx_f_9beam_calc_binary_search(__pyx_v_values, __pyx_v_l, __pyx_v_m, __pyx_v_x);
-      goto __pyx_L0;
+__pyx_f_9beam_calc_fhf_1d(__pyx_t_10, __pyx_t_11, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
+                            __PYX_XDEC_MEMVIEW(&__pyx_t_10, 0);
+                            __pyx_t_10.memview = NULL;
+                            __pyx_t_10.data = NULL;
+                            __PYX_XDEC_MEMVIEW(&__pyx_t_11, 0);
+                            __pyx_t_11.memview = NULL;
+                            __pyx_t_11.data = NULL;
+                        }
+                    }
+                }
+            }
+        }
+        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
+            #undef likely
+            #undef unlikely
+            #define likely(x)   __builtin_expect(!!(x), 1)
+            #define unlikely(x) __builtin_expect(!!(x), 0)
+        #endif
+      }
 
-      /* "beam_calc.pyx":251
- *         elif x > values[m] and x <= values[m + 1]:
- *             return m + 1
- *         elif x < values[m]:             # <<<<<<<<<<<<<<
- *             return binary_search(values, l, m, x)
- *         else:
+      /* "beam_calc.pyx":169
+ *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)
  */
-    }
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L5:;
+      }
+  }
 
-    /* "beam_calc.pyx":254
- *             return binary_search(values, l, m, x)
- *         else:
- *             return binary_search(values, m + 1, r, x)             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":171
+ *     for i in prange(a, schedule='guided', nogil=True):
+ *         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)             # <<<<<<<<<<<<<<
  * 
- * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:
+ * cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
  */
-    /*else*/ {
-      __pyx_r = __pyx_f_9beam_calc_binary_search(__pyx_v_values, (__pyx_v_m + 1), __pyx_v_r, __pyx_v_x);
-      goto __pyx_L0;
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_wf, 2, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(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);
     }
-
-    /* "beam_calc.pyx":246
- * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:
- *     cdef int_t m = l + (r - l) // 2
- *     if l <= r:             # <<<<<<<<<<<<<<
- *         if x == values[m]:
- *             return m
- */
   }
+  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
 
-  /* "beam_calc.pyx":244
- *     return np.asarray(bx_arr)
+  /* "beam_calc.pyx":156
+ *     return np.asarray(wf)
  * 
- * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:             # <<<<<<<<<<<<<<
- *     cdef int_t m = l + (r - l) // 2
- *     if l <= r:
+ * def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
+ *     """
+ *     1D Fraunhofer diffraction calculation for an array of wavefronts (without the coefficient)
  */
 
   /* function exit code */
-  __pyx_r = 0;
+  __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_6, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
+  __Pyx_AddTraceback("beam_calc.fraunhofer_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wf0, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_xx_arr, 1);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":256
- *             return binary_search(values, m + 1, r, x)
+/* "beam_calc.pyx":173
+ *     return np.asarray(wf)
  * 
- * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:             # <<<<<<<<<<<<<<
- *     cdef int_t r = values.shape[0]
- *     if x < values[0]:
+ * cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t a = wf0.shape[0], i
  */
 
-static __pyx_t_9beam_calc_int_t __pyx_f_9beam_calc_searchsorted(__Pyx_memviewslice __pyx_v_values, __pyx_t_9beam_calc_float_t __pyx_v_x) {
-  __pyx_t_9beam_calc_int_t __pyx_v_r;
-  __pyx_t_9beam_calc_int_t __pyx_r;
+static __pyx_t_double_complex __pyx_f_9beam_calc_fnl_wp(__Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __pyx_t_9beam_calc_float_t __pyx_v_xx, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
+  __pyx_t_9beam_calc_int_t __pyx_v_a;
+  __pyx_t_9beam_calc_int_t __pyx_v_i;
+  __pyx_t_9beam_calc_float_t __pyx_v_ph0;
+  __pyx_t_9beam_calc_float_t __pyx_v_ph1;
+  __pyx_t_double_complex __pyx_v_wf;
+  __pyx_t_double_complex __pyx_r;
   Py_ssize_t __pyx_t_1;
-  int __pyx_t_2;
-  __pyx_t_9beam_calc_int_t __pyx_t_3;
+  Py_ssize_t __pyx_t_2;
+  __pyx_t_double_complex __pyx_t_3;
+  __pyx_t_npy_float64_complex __pyx_t_4;
+  __pyx_t_9beam_calc_int_t __pyx_t_5;
+  __pyx_t_9beam_calc_int_t __pyx_t_6;
+  __pyx_t_9beam_calc_int_t __pyx_t_7;
+  __pyx_t_9beam_calc_int_t __pyx_t_8;
+  __pyx_t_9beam_calc_int_t __pyx_t_9;
 
-  /* "beam_calc.pyx":257
- * 
- * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:
- *     cdef int_t r = values.shape[0]             # <<<<<<<<<<<<<<
- *     if x < values[0]:
- *         return 0
+  /* "beam_calc.pyx":175
+ * cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
+ *     cdef:
+ *         int_t a = wf0.shape[0], i             # <<<<<<<<<<<<<<
+ *         float_t ph0, ph1
+ *         complex_t wf
  */
-  __pyx_v_r = (__pyx_v_values.shape[0]);
+  __pyx_v_a = (__pyx_v_wf0.shape[0]);
 
-  /* "beam_calc.pyx":258
- * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:
- *     cdef int_t r = values.shape[0]
- *     if x < values[0]:             # <<<<<<<<<<<<<<
- *         return 0
- *     elif x > values[r - 1]:
+  /* "beam_calc.pyx":178
+ *         float_t ph0, ph1
+ *         complex_t wf
+ *     ph0 = pi / wl / dist * (x_arr[0] - xx)**2             # <<<<<<<<<<<<<<
+ *     ph1 = pi / wl / dist * (x_arr[1] - xx)**2
+ *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
  */
   __pyx_t_1 = 0;
-  __pyx_t_2 = ((__pyx_v_x < (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_1)) )))) != 0);
-  if (__pyx_t_2) {
+  __pyx_v_ph0 = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_dist) * pow(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_1)) ))) - __pyx_v_xx), 2.0));
 
-    /* "beam_calc.pyx":259
- *     cdef int_t r = values.shape[0]
- *     if x < values[0]:
- *         return 0             # <<<<<<<<<<<<<<
- *     elif x > values[r - 1]:
- *         return r
+  /* "beam_calc.pyx":179
+ *         complex_t wf
+ *     ph0 = pi / wl / dist * (x_arr[0] - xx)**2
+ *     ph1 = pi / wl / dist * (x_arr[1] - xx)**2             # <<<<<<<<<<<<<<
+ *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
+ *     for i in range(2, a):
  */
-    __pyx_r = 0;
-    goto __pyx_L0;
+  __pyx_t_1 = 1;
+  __pyx_v_ph1 = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_dist) * pow(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_1)) ))) - __pyx_v_xx), 2.0));
 
-    /* "beam_calc.pyx":258
- * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:
- *     cdef int_t r = values.shape[0]
- *     if x < values[0]:             # <<<<<<<<<<<<<<
- *         return 0
- *     elif x > values[r - 1]:
+  /* "beam_calc.pyx":180
+ *     ph0 = pi / wl / dist * (x_arr[0] - xx)**2
+ *     ph1 = pi / wl / dist * (x_arr[1] - xx)**2
+ *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])             # <<<<<<<<<<<<<<
+ *     for i in range(2, a):
+ *         ph0 = ph1
  */
-  }
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 1;
+  __pyx_t_3 = __Pyx_c_quot_double(__Pyx_c_sum_double(__Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_1)) ))), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph0), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph0), 0)))), __Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_2)) ))), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph1), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph1), 0))))), __pyx_t_double_complex_from_parts(2, 0));
+  __pyx_t_2 = 1;
+  __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_3), __Pyx_CIMAG(__pyx_t_3)), __pyx_t_npy_float64_complex_from_parts(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_2)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_1)) )))), 0));
+  __pyx_v_wf = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_4), __Pyx_CIMAG(__pyx_t_4));
 
-  /* "beam_calc.pyx":260
- *     if x < values[0]:
- *         return 0
- *     elif x > values[r - 1]:             # <<<<<<<<<<<<<<
- *         return r
- *     else:
+  /* "beam_calc.pyx":181
+ *     ph1 = pi / wl / dist * (x_arr[1] - xx)**2
+ *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
+ *     for i in range(2, a):             # <<<<<<<<<<<<<<
+ *         ph0 = ph1
+ *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2
  */
-  __pyx_t_3 = (__pyx_v_r - 1);
-  __pyx_t_2 = ((__pyx_v_x > (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_3)) )))) != 0);
-  if (__pyx_t_2) {
+  __pyx_t_5 = __pyx_v_a;
+  __pyx_t_6 = __pyx_t_5;
+  for (__pyx_t_7 = 2; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
 
-    /* "beam_calc.pyx":261
- *         return 0
- *     elif x > values[r - 1]:
- *         return r             # <<<<<<<<<<<<<<
- *     else:
- *         return binary_search(values, 0, r, x)
+    /* "beam_calc.pyx":182
+ *     wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
+ *     for i in range(2, a):
+ *         ph0 = ph1             # <<<<<<<<<<<<<<
+ *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2
+ *         wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
+ */
+    __pyx_v_ph0 = __pyx_v_ph1;
+
+    /* "beam_calc.pyx":183
+ *     for i in range(2, a):
+ *         ph0 = ph1
+ *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2             # <<<<<<<<<<<<<<
+ *         wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
+ *     return wf
  */
-    __pyx_r = __pyx_v_r;
-    goto __pyx_L0;
+    __pyx_t_8 = __pyx_v_i;
+    __pyx_v_ph1 = (((((__pyx_t_9beam_calc_float_t)M_PI) / __pyx_v_wl) / __pyx_v_dist) * pow(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_8)) ))) - __pyx_v_xx), 2.0));
 
-    /* "beam_calc.pyx":260
- *     if x < values[0]:
- *         return 0
- *     elif x > values[r - 1]:             # <<<<<<<<<<<<<<
- *         return r
- *     else:
+    /* "beam_calc.pyx":184
+ *         ph0 = ph1
+ *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2
+ *         wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])             # <<<<<<<<<<<<<<
+ *     return wf
+ * 
  */
+    __pyx_t_8 = (__pyx_v_i - 1);
+    __pyx_t_9 = __pyx_v_i;
+    __pyx_t_3 = __Pyx_c_quot_double(__Pyx_c_sum_double(__Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_8)) ))), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph0), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph0), 0)))), __Pyx_c_prod_double((*((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf0.data) + __pyx_t_9)) ))), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(cos(__pyx_v_ph1), 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(0, 1.0), __pyx_t_double_complex_from_parts(sin(__pyx_v_ph1), 0))))), __pyx_t_double_complex_from_parts(2, 0));
+    __pyx_t_9 = __pyx_v_i;
+    __pyx_t_8 = (__pyx_v_i - 1);
+    __pyx_t_4 = __Pyx_c_sum_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_v_wf), __Pyx_CIMAG(__pyx_v_wf)), __Pyx_c_prod_npy_float64(__pyx_t_npy_float64_complex_from_parts(__Pyx_CREAL(__pyx_t_3), __Pyx_CIMAG(__pyx_t_3)), __pyx_t_npy_float64_complex_from_parts(((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_9)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_8)) )))), 0)));
+    __pyx_v_wf = __pyx_t_double_complex_from_parts(__Pyx_CREAL(__pyx_t_4), __Pyx_CIMAG(__pyx_t_4));
   }
 
-  /* "beam_calc.pyx":263
- *         return r
- *     else:
- *         return binary_search(values, 0, r, x)             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":185
+ *         ph1 = pi / wl / dist * (x_arr[i] - xx)**2
+ *         wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
+ *     return wf             # <<<<<<<<<<<<<<
  * 
- * cdef void barcode_1d(float_t[::1] br_tr, float_t[::1] x_arr, float_t[::1] bx_arr,
+ * cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
  */
-  /*else*/ {
-    __pyx_r = __pyx_f_9beam_calc_binary_search(__pyx_v_values, 0, __pyx_v_r, __pyx_v_x);
-    goto __pyx_L0;
-  }
+  __pyx_r = __pyx_v_wf;
+  goto __pyx_L0;
 
-  /* "beam_calc.pyx":256
- *             return binary_search(values, m + 1, r, x)
+  /* "beam_calc.pyx":173
+ *     return np.asarray(wf)
  * 
- * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:             # <<<<<<<<<<<<<<
- *     cdef int_t r = values.shape[0]
- *     if x < values[0]:
+ * cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t a = wf0.shape[0], i
  */
 
   /* function exit code */
@@ -6713,234 +5332,346 @@ static __pyx_t_9beam_calc_int_t __pyx_f_9beam_calc_searchsorted(__Pyx_memviewsli
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":265
- *         return binary_search(values, 0, r, x)
+/* "beam_calc.pyx":187
+ *     return wf
  * 
- * cdef void barcode_1d(float_t[::1] br_tr, float_t[::1] x_arr, float_t[::1] bx_arr,             # <<<<<<<<<<<<<<
- *                      float_t sgm, float_t atn, float_t step) nogil:
+ * cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
  *     cdef:
+ *         int_t a = xx_arr.shape[0], i
  */
 
-static void __pyx_f_9beam_calc_barcode_1d(__Pyx_memviewslice __pyx_v_br_tr, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_bx_arr, __pyx_t_9beam_calc_float_t __pyx_v_sgm, __pyx_t_9beam_calc_float_t __pyx_v_atn, __pyx_t_9beam_calc_float_t __pyx_v_step) {
+static void __pyx_f_9beam_calc_fnl_1d(__Pyx_memviewslice __pyx_v_wf1, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
   __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_b;
   __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __pyx_t_9beam_calc_int_t __pyx_v_j0;
-  __pyx_t_9beam_calc_int_t __pyx_v_j;
-  __pyx_t_9beam_calc_float_t __pyx_v_br_dx;
-  __pyx_t_9beam_calc_int_t __pyx_v_bb;
-  __pyx_t_9beam_calc_float_t __pyx_v_tr;
-  __pyx_t_9beam_calc_float_t __pyx_v_xx;
-  __pyx_t_9beam_calc_float_t __pyx_v_x0;
-  __pyx_t_9beam_calc_float_t __pyx_v_x1;
   __pyx_t_9beam_calc_int_t __pyx_t_1;
-  Py_ssize_t __pyx_t_2;
+  __pyx_t_9beam_calc_int_t __pyx_t_2;
   __pyx_t_9beam_calc_int_t __pyx_t_3;
   __pyx_t_9beam_calc_int_t __pyx_t_4;
   __pyx_t_9beam_calc_int_t __pyx_t_5;
-  __pyx_t_9beam_calc_int_t __pyx_t_6;
-  Py_ssize_t __pyx_t_7;
-  __pyx_t_9beam_calc_int_t __pyx_t_8;
-  __pyx_t_9beam_calc_int_t __pyx_t_9;
-  __pyx_t_9beam_calc_int_t __pyx_t_10;
-  int __pyx_t_11;
-  int __pyx_t_12;
-  __pyx_t_9beam_calc_int_t __pyx_t_13;
-  __pyx_t_9beam_calc_int_t __pyx_t_14;
-
-  /* "beam_calc.pyx":268
- *                      float_t sgm, float_t atn, float_t step) nogil:
- *     cdef:
- *         int_t a = x_arr.shape[0], b = bx_arr.shape[0], i, j0, j             # <<<<<<<<<<<<<<
- *         float_t br_dx = (bx_arr[b - 1] - bx_arr[0]) / b
- *         int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)
- */
-  __pyx_v_a = (__pyx_v_x_arr.shape[0]);
-  __pyx_v_b = (__pyx_v_bx_arr.shape[0]);
 
-  /* "beam_calc.pyx":269
+  /* "beam_calc.pyx":189
+ * cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
  *     cdef:
- *         int_t a = x_arr.shape[0], b = bx_arr.shape[0], i, j0, j
- *         float_t br_dx = (bx_arr[b - 1] - bx_arr[0]) / b             # <<<<<<<<<<<<<<
- *         int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)
- *         float_t tr, xx, x0, x1
- */
-  __pyx_t_1 = (__pyx_v_b - 1);
-  __pyx_t_2 = 0;
-  __pyx_v_br_dx = (((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_1)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_2)) )))) / ((__pyx_t_9beam_calc_float_t)__pyx_v_b));
-
-  /* "beam_calc.pyx":270
- *         int_t a = x_arr.shape[0], b = bx_arr.shape[0], i, j0, j
- *         float_t br_dx = (bx_arr[b - 1] - bx_arr[0]) / b
- *         int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)             # <<<<<<<<<<<<<<
- *         float_t tr, xx, x0, x1
+ *         int_t a = xx_arr.shape[0], i             # <<<<<<<<<<<<<<
  *     for i in range(a):
+ *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
  */
-  __pyx_v_bb = ((__pyx_t_9beam_calc_int_t)((((4.320005384913445 * sqrt(2.0)) * __pyx_v_sgm) / __pyx_v_br_dx) + 1.0));
+  __pyx_v_a = (__pyx_v_xx_arr.shape[0]);
 
-  /* "beam_calc.pyx":272
- *         int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)
- *         float_t tr, xx, x0, x1
+  /* "beam_calc.pyx":190
+ *     cdef:
+ *         int_t a = xx_arr.shape[0], i
  *     for i in range(a):             # <<<<<<<<<<<<<<
- *         xx = x_arr[i] - x_arr[0] + step
- *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'
+ *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
+ * 
  */
-  __pyx_t_3 = __pyx_v_a;
-  __pyx_t_4 = __pyx_t_3;
-  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
-    __pyx_v_i = __pyx_t_5;
+  __pyx_t_1 = __pyx_v_a;
+  __pyx_t_2 = __pyx_t_1;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
 
-    /* "beam_calc.pyx":273
- *         float_t tr, xx, x0, x1
+    /* "beam_calc.pyx":191
+ *         int_t a = xx_arr.shape[0], i
  *     for i in range(a):
- *         xx = x_arr[i] - x_arr[0] + step             # <<<<<<<<<<<<<<
- *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'
- *         tr = 0
+ *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)             # <<<<<<<<<<<<<<
+ * 
+ * def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
  */
-    __pyx_t_6 = __pyx_v_i;
-    __pyx_t_7 = 0;
-    __pyx_v_xx = (((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_6)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_7)) )))) + __pyx_v_step);
+    __pyx_t_4 = __pyx_v_i;
+    __pyx_t_5 = __pyx_v_i;
+    *((__pyx_t_double_complex *) ( /* dim=0 */ ((char *) (((__pyx_t_double_complex *) __pyx_v_wf1.data) + __pyx_t_5)) )) = __pyx_f_9beam_calc_fnl_wp(__pyx_v_wf0, __pyx_v_x_arr, (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_xx_arr.data) + __pyx_t_4)) ))), __pyx_v_dist, __pyx_v_wl);
+  }
 
-    /* "beam_calc.pyx":274
- *     for i in range(a):
- *         xx = x_arr[i] - x_arr[0] + step
- *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'             # <<<<<<<<<<<<<<
- *         tr = 0
- *         for j in range(j0 - bb, j0 + bb + 1):
+  /* "beam_calc.pyx":187
+ *     return wf
+ * 
+ * cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t a = xx_arr.shape[0], i
  */
-    __pyx_v_j0 = __pyx_f_9beam_calc_searchsorted(__pyx_v_bx_arr, __pyx_v_xx);
 
-    /* "beam_calc.pyx":275
- *         xx = x_arr[i] - x_arr[0] + step
- *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'
- *         tr = 0             # <<<<<<<<<<<<<<
- *         for j in range(j0 - bb, j0 + bb + 1):
- *             if j >= 1 and j < b:
- */
-    __pyx_v_tr = 0.0;
+  /* function exit code */
+}
 
-    /* "beam_calc.pyx":276
- *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'
- *         tr = 0
- *         for j in range(j0 - bb, j0 + bb + 1):             # <<<<<<<<<<<<<<
- *             if j >= 1 and j < b:
- *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
+/* "beam_calc.pyx":193
+ *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
+ * 
+ * def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
+ *     """
+ *     1D Fresnel diffraction calculation (without the coefficient)
  */
-    __pyx_t_8 = ((__pyx_v_j0 + __pyx_v_bb) + 1);
-    __pyx_t_9 = __pyx_t_8;
-    for (__pyx_t_10 = (__pyx_v_j0 - __pyx_v_bb); __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
-      __pyx_v_j = __pyx_t_10;
 
-      /* "beam_calc.pyx":277
- *         tr = 0
- *         for j in range(j0 - bb, j0 + bb + 1):
- *             if j >= 1 and j < b:             # <<<<<<<<<<<<<<
- *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
- *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
- */
-      __pyx_t_12 = ((__pyx_v_j >= 1) != 0);
-      if (__pyx_t_12) {
-      } else {
-        __pyx_t_11 = __pyx_t_12;
-        goto __pyx_L8_bool_binop_done;
+/* Python wrapper */
+static PyObject *__pyx_pw_9beam_calc_9fresnel_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_8fresnel_1d[] = "\n    1D Fresnel diffraction calculation (without the coefficient)\n\n    wf0 - wavefront at the plane downstream\n    x_arr - coordinates at the plane downstream [um]\n    xx_arr - coordinates at the plane upstream [um]\n    dist - distance between planes [um]\n    wl - wavelength [um]\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_9fresnel_1d = {"fresnel_1d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_9fresnel_1d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_8fresnel_1d};
+static PyObject *__pyx_pw_9beam_calc_9fresnel_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __Pyx_memviewslice __pyx_v_wf0 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_xx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_float_t __pyx_v_dist;
+  __pyx_t_9beam_calc_float_t __pyx_v_wl;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("fresnel_1d (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_wf0,&__pyx_n_s_x_arr,&__pyx_n_s_xx_arr,&__pyx_n_s_dist,&__pyx_n_s_wl,0};
+    PyObject* values[5] = {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  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;
       }
-      __pyx_t_12 = ((__pyx_v_j < __pyx_v_b) != 0);
-      __pyx_t_11 = __pyx_t_12;
-      __pyx_L8_bool_binop_done:;
-      if (__pyx_t_11) {
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wf0)) != 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_x_arr)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, 1); __PYX_ERR(0, 193, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xx_arr)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, 2); __PYX_ERR(0, 193, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, 3); __PYX_ERR(0, 193, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, 4); __PYX_ERR(0, 193, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fresnel_1d") < 0)) __PYX_ERR(0, 193, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
+      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);
+    }
+    __pyx_v_wf0 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_wf0.memview)) __PYX_ERR(0, 193, __pyx_L3_error)
+    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 193, __pyx_L3_error)
+    __pyx_v_xx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_xx_arr.memview)) __PYX_ERR(0, 193, __pyx_L3_error)
+    __pyx_v_dist = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_dist == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 193, __pyx_L3_error)
+    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 193, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("fresnel_1d", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 193, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("beam_calc.fresnel_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_9beam_calc_8fresnel_1d(__pyx_self, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
 
-        /* "beam_calc.pyx":278
- *         for j in range(j0 - bb, j0 + bb + 1):
- *             if j >= 1 and j < b:
- *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm             # <<<<<<<<<<<<<<
- *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
- *                 tr += 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9beam_calc_8fresnel_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
+  __pyx_t_9beam_calc_int_t __pyx_v_a;
+  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("fresnel_1d", 0);
+
+  /* "beam_calc.pyx":204
+ *     """
+ *     cdef:
+ *         int_t a = xx_arr.shape[0]             # <<<<<<<<<<<<<<
+ *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
+ *     fnl_1d(wf, wf0, x_arr, xx_arr, dist, wl)
  */
-        __pyx_t_13 = (__pyx_v_j - 1);
-        __pyx_v_x0 = (((__pyx_v_xx - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_13)) )))) / ((__pyx_t_9beam_calc_float_t)sqrt(2.0))) / __pyx_v_sgm);
+  __pyx_v_a = (__pyx_v_xx_arr.shape[0]);
 
-        /* "beam_calc.pyx":279
- *             if j >= 1 and j < b:
- *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
- *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm             # <<<<<<<<<<<<<<
- *                 tr += 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))
- *         br_tr[i] = sqrt(1 - atn / 2 + atn * tr)
+  /* "beam_calc.pyx":205
+ *     cdef:
+ *         int_t a = xx_arr.shape[0]
+ *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)             # <<<<<<<<<<<<<<
+ *     fnl_1d(wf, wf0, x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)
  */
-        __pyx_t_14 = __pyx_v_j;
-        __pyx_v_x1 = (((__pyx_v_xx - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_14)) )))) / ((__pyx_t_9beam_calc_float_t)sqrt(2.0))) / __pyx_v_sgm);
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_wf = __pyx_t_6;
+  __pyx_t_6.memview = NULL;
+  __pyx_t_6.data = NULL;
 
-        /* "beam_calc.pyx":280
- *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
- *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
- *                 tr += 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))             # <<<<<<<<<<<<<<
- *         br_tr[i] = sqrt(1 - atn / 2 + atn * tr)
+  /* "beam_calc.pyx":206
+ *         int_t a = xx_arr.shape[0]
+ *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
+ *     fnl_1d(wf, wf0, x_arr, xx_arr, dist, wl)             # <<<<<<<<<<<<<<
+ *     return np.asarray(wf)
  * 
  */
-        __pyx_v_tr = (__pyx_v_tr + ((0.5 * (0.5 - (__pyx_v_j % 2))) * (erf(__pyx_v_x0) - erf(__pyx_v_x1))));
-
-        /* "beam_calc.pyx":277
- *         tr = 0
- *         for j in range(j0 - bb, j0 + bb + 1):
- *             if j >= 1 and j < b:             # <<<<<<<<<<<<<<
- *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
- *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
- */
-      }
-    }
+  __pyx_f_9beam_calc_fnl_1d(__pyx_v_wf, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
 
-    /* "beam_calc.pyx":281
- *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
- *                 tr += 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))
- *         br_tr[i] = sqrt(1 - atn / 2 + atn * tr)             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":207
+ *         complex_t[::1] wf = np.empty((a,), dtype=np.complex128)
+ *     fnl_1d(wf, wf0, x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)             # <<<<<<<<<<<<<<
  * 
- * def barcode(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn, float_t ss, int_t nf):
+ * def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
  */
-    __pyx_t_8 = __pyx_v_i;
-    *((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_br_tr.data) + __pyx_t_8)) )) = sqrt(((1.0 - (__pyx_v_atn / 2.0)) + (__pyx_v_atn * __pyx_v_tr)));
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_wf, 1, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
   }
+  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
 
-  /* "beam_calc.pyx":265
- *         return binary_search(values, 0, r, x)
+  /* "beam_calc.pyx":193
+ *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
  * 
- * cdef void barcode_1d(float_t[::1] br_tr, float_t[::1] x_arr, float_t[::1] bx_arr,             # <<<<<<<<<<<<<<
- *                      float_t sgm, float_t atn, float_t step) nogil:
- *     cdef:
+ * def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
+ *     """
+ *     1D Fresnel diffraction calculation (without the coefficient)
  */
 
   /* 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_6, 1);
+  __Pyx_AddTraceback("beam_calc.fresnel_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wf0, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_xx_arr, 1);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
-/* "beam_calc.pyx":283
- *         br_tr[i] = sqrt(1 - atn / 2 + atn * tr)
+/* "beam_calc.pyx":209
+ *     return np.asarray(wf)
  * 
- * def barcode(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn, float_t ss, int_t nf):             # <<<<<<<<<<<<<<
+ * def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
- *     Barcode transmission array for a scan
+ *     1D Fresnel diffraction calculation for an array of wavefronts (without the coefficient)
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_15barcode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_14barcode[] = "\n    Barcode transmission array for a scan\n\n    x_arr - coordinates [um]\n    bx_arr - bar coordinates array [um]\n    sgm - bar haziness width [um]\n    atn - bar attenuation (0.0 - 1.0)\n    ss - scan step size [um]\n    nf - number of frames of a scan\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_15barcode = {"barcode", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_15barcode, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_14barcode};
-static PyObject *__pyx_pw_9beam_calc_15barcode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_9beam_calc_11fresnel_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_10fresnel_2d[] = "\n    1D Fresnel diffraction calculation for an array of wavefronts (without the coefficient)\n\n    wf0 - an array of wavefronts at the plane downstream\n    x_arr - coordinates at the plane downstream [um]\n    xx_arr - coordinates at the plane upstream [um]\n    dist - distance between planes [um]\n    wl - wavelength [um]\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_11fresnel_2d = {"fresnel_2d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_11fresnel_2d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_10fresnel_2d};
+static PyObject *__pyx_pw_9beam_calc_11fresnel_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __Pyx_memviewslice __pyx_v_wf0 = { 0, 0, { 0 }, { 0 }, { 0 } };
   __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_bx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_float_t __pyx_v_sgm;
-  __pyx_t_9beam_calc_float_t __pyx_v_atn;
-  __pyx_t_9beam_calc_float_t __pyx_v_ss;
-  __pyx_t_9beam_calc_int_t __pyx_v_nf;
+  __Pyx_memviewslice __pyx_v_xx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_float_t __pyx_v_dist;
+  __pyx_t_9beam_calc_float_t __pyx_v_wl;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("barcode (wrapper)", 0);
+  __Pyx_RefNannySetupContext("fresnel_2d (wrapper)", 0);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_arr,&__pyx_n_s_bx_arr,&__pyx_n_s_sgm,&__pyx_n_s_atn,&__pyx_n_s_ss,&__pyx_n_s_nf,0};
-    PyObject* values[6] = {0,0,0,0,0,0};
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_wf0,&__pyx_n_s_x_arr,&__pyx_n_s_xx_arr,&__pyx_n_s_dist,&__pyx_n_s_wl,0};
+    PyObject* values[5] = {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  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);
@@ -6957,43 +5688,37 @@ static PyObject *__pyx_pw_9beam_calc_15barcode(PyObject *__pyx_self, PyObject *_
       kw_args = PyDict_Size(__pyx_kwds);
       switch (pos_args) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_arr)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wf0)) != 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_bx_arr)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_arr)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("barcode", 1, 6, 6, 1); __PYX_ERR(0, 283, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, 1); __PYX_ERR(0, 209, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sgm)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xx_arr)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("barcode", 1, 6, 6, 2); __PYX_ERR(0, 283, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, 2); __PYX_ERR(0, 209, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atn)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("barcode", 1, 6, 6, 3); __PYX_ERR(0, 283, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, 3); __PYX_ERR(0, 209, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ss)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("barcode", 1, 6, 6, 4); __PYX_ERR(0, 283, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nf)) != 0)) kw_args--;
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_wl)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("barcode", 1, 6, 6, 5); __PYX_ERR(0, 283, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, 4); __PYX_ERR(0, 209, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "barcode") < 0)) __PYX_ERR(0, 283, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fresnel_2d") < 0)) __PYX_ERR(0, 209, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 6) {
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
       goto __pyx_L5_argtuple_error;
     } else {
       values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
@@ -7001,34 +5726,33 @@ static PyObject *__pyx_pw_9beam_calc_15barcode(PyObject *__pyx_self, PyObject *_
       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);
     }
-    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 283, __pyx_L3_error)
-    __pyx_v_bx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_bx_arr.memview)) __PYX_ERR(0, 283, __pyx_L3_error)
-    __pyx_v_sgm = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_sgm == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
-    __pyx_v_atn = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_atn == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
-    __pyx_v_ss = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_ss == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
-    __pyx_v_nf = __Pyx_PyInt_As_npy_int64(values[5]); if (unlikely((__pyx_v_nf == ((npy_int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
+    __pyx_v_wf0 = __Pyx_PyObject_to_MemoryviewSlice_d_dc___pyx_t_double_complex(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_wf0.memview)) __PYX_ERR(0, 209, __pyx_L3_error)
+    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 209, __pyx_L3_error)
+    __pyx_v_xx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_xx_arr.memview)) __PYX_ERR(0, 209, __pyx_L3_error)
+    __pyx_v_dist = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_dist == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 209, __pyx_L3_error)
+    __pyx_v_wl = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_wl == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 209, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("barcode", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 283, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("fresnel_2d", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 209, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("beam_calc.barcode", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("beam_calc.fresnel_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_14barcode(__pyx_self, __pyx_v_x_arr, __pyx_v_bx_arr, __pyx_v_sgm, __pyx_v_atn, __pyx_v_ss, __pyx_v_nf);
+  __pyx_r = __pyx_pf_9beam_calc_10fresnel_2d(__pyx_self, __pyx_v_wf0, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_9beam_calc_14barcode(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_bx_arr, __pyx_t_9beam_calc_float_t __pyx_v_sgm, __pyx_t_9beam_calc_float_t __pyx_v_atn, __pyx_t_9beam_calc_float_t __pyx_v_ss, __pyx_t_9beam_calc_int_t __pyx_v_nf) {
+static PyObject *__pyx_pf_9beam_calc_10fresnel_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_wf0, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_xx_arr, __pyx_t_9beam_calc_float_t __pyx_v_dist, __pyx_t_9beam_calc_float_t __pyx_v_wl) {
   __pyx_t_9beam_calc_int_t __pyx_v_a;
+  __pyx_t_9beam_calc_int_t __pyx_v_b;
   __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __Pyx_memviewslice __pyx_v_bc_t = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
@@ -7041,34 +5765,39 @@ static PyObject *__pyx_pf_9beam_calc_14barcode(CYTHON_UNUSED PyObject *__pyx_sel
   __pyx_t_9beam_calc_int_t __pyx_t_8;
   __pyx_t_9beam_calc_int_t __pyx_t_9;
   __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_RefNannySetupContext("barcode", 0);
+  __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("fresnel_2d", 0);
 
-  /* "beam_calc.pyx":295
+  /* "beam_calc.pyx":220
  *     """
  *     cdef:
- *         int_t a = x_arr.shape[0], i             # <<<<<<<<<<<<<<
- *         float_t[:, ::1] bc_t = np.empty((nf, a), dtype=np.float64)
- *     for i in prange(nf, schedule='guided', nogil=True):
+ *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i             # <<<<<<<<<<<<<<
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True):
  */
-  __pyx_v_a = (__pyx_v_x_arr.shape[0]);
+  __pyx_v_a = (__pyx_v_wf0.shape[0]);
+  __pyx_v_b = (__pyx_v_xx_arr.shape[0]);
 
-  /* "beam_calc.pyx":296
+  /* "beam_calc.pyx":221
  *     cdef:
- *         int_t a = x_arr.shape[0], i
- *         float_t[:, ::1] bc_t = np.empty((nf, a), dtype=np.float64)             # <<<<<<<<<<<<<<
- *     for i in prange(nf, schedule='guided', nogil=True):
- *         barcode_1d(bc_t[i], x_arr, bx_arr, sgm, atn, i * ss)
+ *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)             # <<<<<<<<<<<<<<
+ *     for i in prange(a, schedule='guided', nogil=True):
+ *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_nf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_GIVEREF(__pyx_t_1);
   PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
@@ -7076,37 +5805,37 @@ static PyObject *__pyx_pf_9beam_calc_14barcode(CYTHON_UNUSED PyObject *__pyx_sel
   PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
   __pyx_t_1 = 0;
   __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_4);
   PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
   __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 296, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_float_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 296, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc___pyx_t_double_complex(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_bc_t = __pyx_t_6;
+  __pyx_v_wf = __pyx_t_6;
   __pyx_t_6.memview = NULL;
   __pyx_t_6.data = NULL;
 
-  /* "beam_calc.pyx":297
- *         int_t a = x_arr.shape[0], i
- *         float_t[:, ::1] bc_t = np.empty((nf, a), dtype=np.float64)
- *     for i in prange(nf, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         barcode_1d(bc_t[i], x_arr, bx_arr, sgm, atn, i * ss)
- *     return np.asarray(bc_t)
+  /* "beam_calc.pyx":222
+ *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)
  */
   {
       #ifdef WITH_THREAD
@@ -7115,14 +5844,9 @@ static PyObject *__pyx_pf_9beam_calc_14barcode(CYTHON_UNUSED PyObject *__pyx_sel
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
-        __pyx_t_7 = __pyx_v_nf;
+        __pyx_t_7 = __pyx_v_a;
         if ((1 == 0)) abort();
         {
-            __pyx_t_9beam_calc_int_t __pyx_parallel_temp0 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
-            const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0;
-            PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL;
-            int __pyx_parallel_why;
-            __pyx_parallel_why = 0;
             #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                 #undef likely
                 #undef unlikely
@@ -7133,120 +5857,59 @@ static PyObject *__pyx_pf_9beam_calc_14barcode(CYTHON_UNUSED PyObject *__pyx_sel
             if (__pyx_t_9 > 0)
             {
                 #ifdef _OPENMP
-                #pragma omp parallel firstprivate(__pyx_t_10) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb)
+                #pragma omp parallel firstprivate(__pyx_t_10, __pyx_t_11)
                 #endif /* _OPENMP */
                 {
-                    #ifdef _OPENMP
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    Py_BEGIN_ALLOW_THREADS
-                    #endif /* _OPENMP */
                     #ifdef _OPENMP
                     #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) schedule(guided)
                     #endif /* _OPENMP */
                     for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
-                        if (__pyx_parallel_why < 2)
                         {
                             __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
 
-                            /* "beam_calc.pyx":298
- *         float_t[:, ::1] bc_t = np.empty((nf, a), dtype=np.float64)
- *     for i in prange(nf, schedule='guided', nogil=True):
- *         barcode_1d(bc_t[i], x_arr, bx_arr, sgm, atn, i * ss)             # <<<<<<<<<<<<<<
- *     return np.asarray(bc_t)
+                            /* "beam_calc.pyx":223
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True):
+ *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)             # <<<<<<<<<<<<<<
+ *     return np.asarray(wf)
  * 
  */
-                            __pyx_t_10.data = __pyx_v_bc_t.data;
-                            __pyx_t_10.memview = __pyx_v_bc_t.memview;
+                            __pyx_t_10.data = __pyx_v_wf.data;
+                            __pyx_t_10.memview = __pyx_v_wf.memview;
                             __PYX_INC_MEMVIEW(&__pyx_t_10, 0);
                             {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_bc_t.strides[0];
-        if ((0)) __PYX_ERR(0, 298, __pyx_L8_error)
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_wf.strides[0];
         __pyx_t_10.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
-__pyx_t_10.shape[0] = __pyx_v_bc_t.shape[1];
-__pyx_t_10.strides[0] = __pyx_v_bc_t.strides[1];
+__pyx_t_10.shape[0] = __pyx_v_wf.shape[1];
+__pyx_t_10.strides[0] = __pyx_v_wf.strides[1];
     __pyx_t_10.suboffsets[0] = -1;
 
-__pyx_f_9beam_calc_barcode_1d(__pyx_t_10, __pyx_v_x_arr, __pyx_v_bx_arr, __pyx_v_sgm, __pyx_v_atn, (__pyx_v_i * __pyx_v_ss));
-                            __PYX_XDEC_MEMVIEW(&__pyx_t_10, 0);
-                            __pyx_t_10.memview = NULL;
-                            __pyx_t_10.data = NULL;
-                            goto __pyx_L11;
-                            __pyx_L8_error:;
-                            {
-                                #ifdef WITH_THREAD
-                                PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                                #endif
-                                #ifdef _OPENMP
-                                #pragma omp flush(__pyx_parallel_exc_type)
-                                #endif /* _OPENMP */
-                                if (!__pyx_parallel_exc_type) {
-                                  __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
-                                  __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
-                                  __Pyx_GOTREF(__pyx_parallel_exc_type);
-                                }
-                                #ifdef WITH_THREAD
-                                __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                                #endif
-                            }
-                            __pyx_parallel_why = 4;
-                            goto __pyx_L10;
-                            __pyx_L10:;
-                            #ifdef _OPENMP
-                            #pragma omp critical(__pyx_parallel_lastprivates2)
-                            #endif /* _OPENMP */
-                            {
-                                __pyx_parallel_temp0 = __pyx_v_i;
-                            }
-                            __pyx_L11:;
-                            #ifdef _OPENMP
-                            #pragma omp flush(__pyx_parallel_why)
-                            #endif /* _OPENMP */
-                        }
-                    }
-                    #ifdef _OPENMP
-                    Py_END_ALLOW_THREADS
-                    #else
-{
-#ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    #endif /* _OPENMP */
-                    /* Clean up any temporaries */
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_10, 0);
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
-                    #ifndef _OPENMP
-}
-#endif /* _OPENMP */
-                }
-            }
-            if (__pyx_parallel_exc_type) {
-              /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
-              __pyx_parallel_why = 4;
-            }
-            if (__pyx_parallel_why) {
-              __pyx_v_i = __pyx_parallel_temp0;
-              switch (__pyx_parallel_why) {
-                    case 4:
-                {
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    __Pyx_GIVEREF(__pyx_parallel_exc_type);
-                    __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
-                    __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
+__pyx_t_11.data = __pyx_v_wf0.data;
+                            __pyx_t_11.memview = __pyx_v_wf0.memview;
+                            __PYX_INC_MEMVIEW(&__pyx_t_11, 0);
+                            {
+    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_wf0.strides[0];
+        __pyx_t_11.data += __pyx_tmp_idx * __pyx_tmp_stride;
+}
+
+__pyx_t_11.shape[0] = __pyx_v_wf0.shape[1];
+__pyx_t_11.strides[0] = __pyx_v_wf0.strides[1];
+    __pyx_t_11.suboffsets[0] = -1;
+
+__pyx_f_9beam_calc_fnl_1d(__pyx_t_10, __pyx_t_11, __pyx_v_x_arr, __pyx_v_xx_arr, __pyx_v_dist, __pyx_v_wl);
+                            __PYX_XDEC_MEMVIEW(&__pyx_t_10, 0);
+                            __pyx_t_10.memview = NULL;
+                            __pyx_t_10.data = NULL;
+                            __PYX_XDEC_MEMVIEW(&__pyx_t_11, 0);
+                            __pyx_t_11.memview = NULL;
+                            __pyx_t_11.data = NULL;
+                        }
+                    }
                 }
-                goto __pyx_L4_error;
-              }
             }
         }
         #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
@@ -7257,12 +5920,12 @@ __pyx_f_9beam_calc_barcode_1d(__pyx_t_10, __pyx_v_x_arr, __pyx_v_bx_arr, __pyx_v
         #endif
       }
 
-      /* "beam_calc.pyx":297
- *         int_t a = x_arr.shape[0], i
- *         float_t[:, ::1] bc_t = np.empty((nf, a), dtype=np.float64)
- *     for i in prange(nf, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         barcode_1d(bc_t[i], x_arr, bx_arr, sgm, atn, i * ss)
- *     return np.asarray(bc_t)
+      /* "beam_calc.pyx":222
+ *         int_t a = wf0.shape[0], b = xx_arr.shape[0], i
+ *         complex_t[:, ::1] wf = np.empty((a, b), dtype=np.complex128)
+ *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)
  */
       /*finally:*/ {
         /*normal exit:*/{
@@ -7272,31 +5935,24 @@ __pyx_f_9beam_calc_barcode_1d(__pyx_t_10, __pyx_v_x_arr, __pyx_v_bx_arr, __pyx_v
           #endif
           goto __pyx_L5;
         }
-        __pyx_L4_error: {
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L1_error;
-        }
         __pyx_L5:;
       }
   }
 
-  /* "beam_calc.pyx":299
- *     for i in prange(nf, schedule='guided', nogil=True):
- *         barcode_1d(bc_t[i], x_arr, bx_arr, sgm, atn, i * ss)
- *     return np.asarray(bc_t)             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":224
+ *     for i in prange(a, schedule='guided', nogil=True):
+ *         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
+ *     return np.asarray(wf)             # <<<<<<<<<<<<<<
  * 
- * cdef float_t convolve_c(float_t[::1] a1, float_t[::1] a2, int_t k) nogil:
+ * def barcode_steps(float_t x0, float_t x1, float_t br_dx, float_t rd):
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 299, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_bc_t, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_9beam_calc_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_9beam_calc_float_t, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 299, __pyx_L1_error)
+  __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_wf, 2, (PyObject *(*)(char *)) __pyx_memview_get___pyx_t_double_complex, (int (*)(char *, PyObject *)) __pyx_memview_set___pyx_t_double_complex, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
@@ -7305,153 +5961,644 @@ __pyx_f_9beam_calc_barcode_1d(__pyx_t_10, __pyx_v_x_arr, __pyx_v_bx_arr, __pyx_v
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
       __Pyx_INCREF(__pyx_t_2);
       __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_3, function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "beam_calc.pyx":209
+ *     return np.asarray(wf)
+ * 
+ * def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
+ *     """
+ *     1D Fresnel diffraction calculation for an array of wavefronts (without the coefficient)
+ */
+
+  /* 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_6, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
+  __Pyx_AddTraceback("beam_calc.fresnel_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wf0, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_xx_arr, 1);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":226
+ *     return np.asarray(wf)
+ * 
+ * def barcode_steps(float_t x0, float_t x1, float_t br_dx, float_t rd):             # <<<<<<<<<<<<<<
+ *     """
+ *     Barcode bars' coordinates generation with random deviation
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9beam_calc_13barcode_steps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_12barcode_steps[] = "\n    Barcode bars' coordinates generation with random deviation\n\n    x0, x1 - sample's bounds [um]\n    br_dx - mean bar size [um]\n    rd - random deviation (0.0 - 1.0)\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_13barcode_steps = {"barcode_steps", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_13barcode_steps, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_12barcode_steps};
+static PyObject *__pyx_pw_9beam_calc_13barcode_steps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __pyx_t_9beam_calc_float_t __pyx_v_x0;
+  __pyx_t_9beam_calc_float_t __pyx_v_x1;
+  __pyx_t_9beam_calc_float_t __pyx_v_br_dx;
+  __pyx_t_9beam_calc_float_t __pyx_v_rd;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("barcode_steps (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x0,&__pyx_n_s_x1,&__pyx_n_s_br_dx,&__pyx_n_s_rd,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_x0)) != 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_x1)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("barcode_steps", 1, 4, 4, 1); __PYX_ERR(0, 226, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_br_dx)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("barcode_steps", 1, 4, 4, 2); __PYX_ERR(0, 226, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rd)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("barcode_steps", 1, 4, 4, 3); __PYX_ERR(0, 226, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "barcode_steps") < 0)) __PYX_ERR(0, 226, __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_x0 = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x0 == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 226, __pyx_L3_error)
+    __pyx_v_x1 = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_x1 == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 226, __pyx_L3_error)
+    __pyx_v_br_dx = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_br_dx == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 226, __pyx_L3_error)
+    __pyx_v_rd = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_rd == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 226, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("barcode_steps", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 226, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("beam_calc.barcode_steps", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_9beam_calc_12barcode_steps(__pyx_self, __pyx_v_x0, __pyx_v_x1, __pyx_v_br_dx, __pyx_v_rd);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9beam_calc_12barcode_steps(CYTHON_UNUSED PyObject *__pyx_self, __pyx_t_9beam_calc_float_t __pyx_v_x0, __pyx_t_9beam_calc_float_t __pyx_v_x1, __pyx_t_9beam_calc_float_t __pyx_v_br_dx, __pyx_t_9beam_calc_float_t __pyx_v_rd) {
+  __pyx_t_9beam_calc_int_t __pyx_v_br_n;
+  __pyx_t_9beam_calc_int_t __pyx_v_i;
+  gsl_rng *__pyx_v_r;
+  __pyx_t_9beam_calc_float_t __pyx_v_bs_min;
+  __pyx_t_9beam_calc_float_t __pyx_v_bs_max;
+  __Pyx_memviewslice __pyx_v_bx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_9beam_calc_int_t __pyx_t_1;
+  long __pyx_t_2;
+  __pyx_t_9beam_calc_float_t __pyx_t_3;
+  __pyx_t_9beam_calc_float_t __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  __pyx_t_9beam_calc_int_t __pyx_t_13;
+  __pyx_t_9beam_calc_int_t __pyx_t_14;
+  __pyx_t_9beam_calc_int_t __pyx_t_15;
+  __pyx_t_9beam_calc_int_t __pyx_t_16;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("barcode_steps", 0);
+
+  /* "beam_calc.pyx":235
+ *     """
+ *     cdef:
+ *         int_t br_n = <int_t>((x1 - x0) / 2 / br_dx) * 2 if x1 - x0 > 0 else 0, i             # <<<<<<<<<<<<<<
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
+ *         float_t bs_min = max(1 - rd, 0), bs_max = min(1 + rd, 2)
+ */
+  if ((((__pyx_v_x1 - __pyx_v_x0) > 0.0) != 0)) {
+    __pyx_t_1 = (((__pyx_t_9beam_calc_int_t)(((__pyx_v_x1 - __pyx_v_x0) / 2.0) / __pyx_v_br_dx)) * 2);
+  } else {
+    __pyx_t_1 = 0;
+  }
+  __pyx_v_br_n = __pyx_t_1;
+
+  /* "beam_calc.pyx":236
+ *     cdef:
+ *         int_t br_n = <int_t>((x1 - x0) / 2 / br_dx) * 2 if x1 - x0 > 0 else 0, i
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)             # <<<<<<<<<<<<<<
+ *         float_t bs_min = max(1 - rd, 0), bs_max = min(1 + rd, 2)
+ *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
+ */
+  __pyx_v_r = gsl_rng_alloc(gsl_rng_mt19937);
+
+  /* "beam_calc.pyx":237
+ *         int_t br_n = <int_t>((x1 - x0) / 2 / br_dx) * 2 if x1 - x0 > 0 else 0, i
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
+ *         float_t bs_min = max(1 - rd, 0), bs_max = min(1 + rd, 2)             # <<<<<<<<<<<<<<
+ *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
+ *     if br_n:
+ */
+  __pyx_t_2 = 0;
+  __pyx_t_3 = (1.0 - __pyx_v_rd);
+  if (((__pyx_t_2 > __pyx_t_3) != 0)) {
+    __pyx_t_4 = __pyx_t_2;
+  } else {
+    __pyx_t_4 = __pyx_t_3;
+  }
+  __pyx_v_bs_min = __pyx_t_4;
+  __pyx_t_2 = 2;
+  __pyx_t_4 = (1.0 + __pyx_v_rd);
+  if (((__pyx_t_2 < __pyx_t_4) != 0)) {
+    __pyx_t_3 = __pyx_t_2;
+  } else {
+    __pyx_t_3 = __pyx_t_4;
+  }
+  __pyx_v_bs_max = __pyx_t_3;
+
+  /* "beam_calc.pyx":238
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
+ *         float_t bs_min = max(1 - rd, 0), bs_max = min(1 + rd, 2)
+ *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)             # <<<<<<<<<<<<<<
+ *     if br_n:
+ *         bx_arr[0] = x0 + br_dx * ((bs_max - bs_min) * gsl_rng_uniform_pos(r) - 1)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_npy_int64(__pyx_v_br_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_float64); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __pyx_v_bx_arr = __pyx_t_10;
+  __pyx_t_10.memview = NULL;
+  __pyx_t_10.data = NULL;
+
+  /* "beam_calc.pyx":239
+ *         float_t bs_min = max(1 - rd, 0), bs_max = min(1 + rd, 2)
+ *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
+ *     if br_n:             # <<<<<<<<<<<<<<
+ *         bx_arr[0] = x0 + br_dx * ((bs_max - bs_min) * gsl_rng_uniform_pos(r) - 1)
+ *         for i in range(1, br_n):
+ */
+  __pyx_t_11 = (__pyx_v_br_n != 0);
+  if (__pyx_t_11) {
+
+    /* "beam_calc.pyx":240
+ *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
+ *     if br_n:
+ *         bx_arr[0] = x0 + br_dx * ((bs_max - bs_min) * gsl_rng_uniform_pos(r) - 1)             # <<<<<<<<<<<<<<
+ *         for i in range(1, br_n):
+ *             bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
+ */
+    __pyx_t_12 = 0;
+    *((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_12)) )) = (__pyx_v_x0 + (__pyx_v_br_dx * (((__pyx_v_bs_max - __pyx_v_bs_min) * gsl_rng_uniform_pos(__pyx_v_r)) - 1.0)));
+
+    /* "beam_calc.pyx":241
+ *     if br_n:
+ *         bx_arr[0] = x0 + br_dx * ((bs_max - bs_min) * gsl_rng_uniform_pos(r) - 1)
+ *         for i in range(1, br_n):             # <<<<<<<<<<<<<<
+ *             bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
+ *     return np.asarray(bx_arr)
+ */
+    __pyx_t_1 = __pyx_v_br_n;
+    __pyx_t_13 = __pyx_t_1;
+    for (__pyx_t_14 = 1; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
+      __pyx_v_i = __pyx_t_14;
+
+      /* "beam_calc.pyx":242
+ *         bx_arr[0] = x0 + br_dx * ((bs_max - bs_min) * gsl_rng_uniform_pos(r) - 1)
+ *         for i in range(1, br_n):
+ *             bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))             # <<<<<<<<<<<<<<
+ *     return np.asarray(bx_arr)
+ * 
+ */
+      __pyx_t_15 = (__pyx_v_i - 1);
+      __pyx_t_16 = __pyx_v_i;
+      *((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_16)) )) = ((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_15)) ))) + (__pyx_v_br_dx * (__pyx_v_bs_min + ((__pyx_v_bs_max - __pyx_v_bs_min) * gsl_rng_uniform_pos(__pyx_v_r)))));
+    }
+
+    /* "beam_calc.pyx":239
+ *         float_t bs_min = max(1 - rd, 0), bs_max = min(1 + rd, 2)
+ *         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
+ *     if br_n:             # <<<<<<<<<<<<<<
+ *         bx_arr[0] = x0 + br_dx * ((bs_max - bs_min) * gsl_rng_uniform_pos(r) - 1)
+ *         for i in range(1, br_n):
+ */
+  }
+
+  /* "beam_calc.pyx":243
+ *         for i in range(1, br_n):
+ *             bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
+ *     return np.asarray(bx_arr)             # <<<<<<<<<<<<<<
+ * 
+ * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_asarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __pyx_memoryview_fromslice(__pyx_v_bx_arr, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_9beam_calc_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_9beam_calc_float_t, 0);; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_7, function);
     }
   }
-  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 299, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_5;
-  __pyx_t_5 = 0;
+  __pyx_t_9 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_9;
+  __pyx_t_9 = 0;
   goto __pyx_L0;
 
-  /* "beam_calc.pyx":283
- *         br_tr[i] = sqrt(1 - atn / 2 + atn * tr)
+  /* "beam_calc.pyx":226
+ *     return np.asarray(wf)
  * 
- * def barcode(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn, float_t ss, int_t nf):             # <<<<<<<<<<<<<<
+ * def barcode_steps(float_t x0, float_t x1, float_t br_dx, float_t rd):             # <<<<<<<<<<<<<<
  *     """
- *     Barcode transmission array for a scan
+ *     Barcode bars' coordinates generation with random deviation
  */
 
   /* 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_6, 1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
   __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
-  __Pyx_AddTraceback("beam_calc.barcode", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("beam_calc.barcode_steps", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_bc_t, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
   __PYX_XDEC_MEMVIEW(&__pyx_v_bx_arr, 1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":301
- *     return np.asarray(bc_t)
+/* "beam_calc.pyx":245
+ *     return np.asarray(bx_arr)
  * 
- * cdef float_t convolve_c(float_t[::1] a1, float_t[::1] a2, int_t k) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = a1.shape[0], b = a2.shape[0]
+ * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:             # <<<<<<<<<<<<<<
+ *     cdef int_t m = l + (r - l) // 2
+ *     if l <= r:
  */
 
-static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_convolve_c(__Pyx_memviewslice __pyx_v_a1, __Pyx_memviewslice __pyx_v_a2, __pyx_t_9beam_calc_int_t __pyx_v_k) {
-  __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_b;
-  __pyx_t_9beam_calc_int_t __pyx_v_i0;
-  __pyx_t_9beam_calc_int_t __pyx_v_i1;
-  __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __pyx_t_9beam_calc_float_t __pyx_v_x;
-  __pyx_t_9beam_calc_float_t __pyx_r;
-  long __pyx_t_1;
+static __pyx_t_9beam_calc_int_t __pyx_f_9beam_calc_binary_search(__Pyx_memviewslice __pyx_v_values, __pyx_t_9beam_calc_int_t __pyx_v_l, __pyx_t_9beam_calc_int_t __pyx_v_r, __pyx_t_9beam_calc_float_t __pyx_v_x) {
+  __pyx_t_9beam_calc_int_t __pyx_v_m;
+  __pyx_t_9beam_calc_int_t __pyx_r;
+  int __pyx_t_1;
   __pyx_t_9beam_calc_int_t __pyx_t_2;
+  int __pyx_t_3;
+
+  /* "beam_calc.pyx":246
+ * 
+ * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:
+ *     cdef int_t m = l + (r - l) // 2             # <<<<<<<<<<<<<<
+ *     if l <= r:
+ *         if x == values[m]:
+ */
+  __pyx_v_m = (__pyx_v_l + ((__pyx_v_r - __pyx_v_l) / 2));
+
+  /* "beam_calc.pyx":247
+ * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:
+ *     cdef int_t m = l + (r - l) // 2
+ *     if l <= r:             # <<<<<<<<<<<<<<
+ *         if x == values[m]:
+ *             return m
+ */
+  __pyx_t_1 = ((__pyx_v_l <= __pyx_v_r) != 0);
+  if (__pyx_t_1) {
+
+    /* "beam_calc.pyx":248
+ *     cdef int_t m = l + (r - l) // 2
+ *     if l <= r:
+ *         if x == values[m]:             # <<<<<<<<<<<<<<
+ *             return m
+ *         elif x > values[m] and x <= values[m + 1]:
+ */
+    __pyx_t_2 = __pyx_v_m;
+    __pyx_t_1 = ((__pyx_v_x == (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_2)) )))) != 0);
+    if (__pyx_t_1) {
+
+      /* "beam_calc.pyx":249
+ *     if l <= r:
+ *         if x == values[m]:
+ *             return m             # <<<<<<<<<<<<<<
+ *         elif x > values[m] and x <= values[m + 1]:
+ *             return m + 1
+ */
+      __pyx_r = __pyx_v_m;
+      goto __pyx_L0;
+
+      /* "beam_calc.pyx":248
+ *     cdef int_t m = l + (r - l) // 2
+ *     if l <= r:
+ *         if x == values[m]:             # <<<<<<<<<<<<<<
+ *             return m
+ *         elif x > values[m] and x <= values[m + 1]:
+ */
+    }
+
+    /* "beam_calc.pyx":250
+ *         if x == values[m]:
+ *             return m
+ *         elif x > values[m] and x <= values[m + 1]:             # <<<<<<<<<<<<<<
+ *             return m + 1
+ *         elif x < values[m]:
+ */
+    __pyx_t_2 = __pyx_v_m;
+    __pyx_t_3 = ((__pyx_v_x > (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_2)) )))) != 0);
+    if (__pyx_t_3) {
+    } else {
+      __pyx_t_1 = __pyx_t_3;
+      goto __pyx_L5_bool_binop_done;
+    }
+    __pyx_t_2 = (__pyx_v_m + 1);
+    __pyx_t_3 = ((__pyx_v_x <= (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_2)) )))) != 0);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_L5_bool_binop_done:;
+    if (__pyx_t_1) {
+
+      /* "beam_calc.pyx":251
+ *             return m
+ *         elif x > values[m] and x <= values[m + 1]:
+ *             return m + 1             # <<<<<<<<<<<<<<
+ *         elif x < values[m]:
+ *             return binary_search(values, l, m, x)
+ */
+      __pyx_r = (__pyx_v_m + 1);
+      goto __pyx_L0;
+
+      /* "beam_calc.pyx":250
+ *         if x == values[m]:
+ *             return m
+ *         elif x > values[m] and x <= values[m + 1]:             # <<<<<<<<<<<<<<
+ *             return m + 1
+ *         elif x < values[m]:
+ */
+    }
+
+    /* "beam_calc.pyx":252
+ *         elif x > values[m] and x <= values[m + 1]:
+ *             return m + 1
+ *         elif x < values[m]:             # <<<<<<<<<<<<<<
+ *             return binary_search(values, l, m, x)
+ *         else:
+ */
+    __pyx_t_2 = __pyx_v_m;
+    __pyx_t_1 = ((__pyx_v_x < (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_2)) )))) != 0);
+    if (__pyx_t_1) {
+
+      /* "beam_calc.pyx":253
+ *             return m + 1
+ *         elif x < values[m]:
+ *             return binary_search(values, l, m, x)             # <<<<<<<<<<<<<<
+ *         else:
+ *             return binary_search(values, m + 1, r, x)
+ */
+      __pyx_r = __pyx_f_9beam_calc_binary_search(__pyx_v_values, __pyx_v_l, __pyx_v_m, __pyx_v_x);
+      goto __pyx_L0;
+
+      /* "beam_calc.pyx":252
+ *         elif x > values[m] and x <= values[m + 1]:
+ *             return m + 1
+ *         elif x < values[m]:             # <<<<<<<<<<<<<<
+ *             return binary_search(values, l, m, x)
+ *         else:
+ */
+    }
+
+    /* "beam_calc.pyx":255
+ *             return binary_search(values, l, m, x)
+ *         else:
+ *             return binary_search(values, m + 1, r, x)             # <<<<<<<<<<<<<<
+ * 
+ * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:
+ */
+    /*else*/ {
+      __pyx_r = __pyx_f_9beam_calc_binary_search(__pyx_v_values, (__pyx_v_m + 1), __pyx_v_r, __pyx_v_x);
+      goto __pyx_L0;
+    }
+
+    /* "beam_calc.pyx":247
+ * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:
+ *     cdef int_t m = l + (r - l) // 2
+ *     if l <= r:             # <<<<<<<<<<<<<<
+ *         if x == values[m]:
+ *             return m
+ */
+  }
+
+  /* "beam_calc.pyx":245
+ *     return np.asarray(bx_arr)
+ * 
+ * cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:             # <<<<<<<<<<<<<<
+ *     cdef int_t m = l + (r - l) // 2
+ *     if l <= r:
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":257
+ *             return binary_search(values, m + 1, r, x)
+ * 
+ * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:             # <<<<<<<<<<<<<<
+ *     cdef int_t r = values.shape[0]
+ *     if x < values[0]:
+ */
+
+static __pyx_t_9beam_calc_int_t __pyx_f_9beam_calc_searchsorted(__Pyx_memviewslice __pyx_v_values, __pyx_t_9beam_calc_float_t __pyx_v_x) {
+  __pyx_t_9beam_calc_int_t __pyx_v_r;
+  __pyx_t_9beam_calc_int_t __pyx_r;
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
   __pyx_t_9beam_calc_int_t __pyx_t_3;
-  __pyx_t_9beam_calc_int_t __pyx_t_4;
-  __pyx_t_9beam_calc_int_t __pyx_t_5;
-  __pyx_t_9beam_calc_int_t __pyx_t_6;
 
-  /* "beam_calc.pyx":303
- * cdef float_t convolve_c(float_t[::1] a1, float_t[::1] a2, int_t k) nogil:
- *     cdef:
- *         int_t a = a1.shape[0], b = a2.shape[0]             # <<<<<<<<<<<<<<
- *         int_t i0 = max(k - b // 2, 0), i1 = min(k - b//2 + b, a), i
- *         float_t x = 0
+  /* "beam_calc.pyx":258
+ * 
+ * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:
+ *     cdef int_t r = values.shape[0]             # <<<<<<<<<<<<<<
+ *     if x < values[0]:
+ *         return 0
  */
-  __pyx_v_a = (__pyx_v_a1.shape[0]);
-  __pyx_v_b = (__pyx_v_a2.shape[0]);
+  __pyx_v_r = (__pyx_v_values.shape[0]);
 
-  /* "beam_calc.pyx":304
- *     cdef:
- *         int_t a = a1.shape[0], b = a2.shape[0]
- *         int_t i0 = max(k - b // 2, 0), i1 = min(k - b//2 + b, a), i             # <<<<<<<<<<<<<<
- *         float_t x = 0
- *     for i in range(i0, i1):
+  /* "beam_calc.pyx":259
+ * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:
+ *     cdef int_t r = values.shape[0]
+ *     if x < values[0]:             # <<<<<<<<<<<<<<
+ *         return 0
+ *     elif x > values[r - 1]:
+ */
+  __pyx_t_1 = 0;
+  __pyx_t_2 = ((__pyx_v_x < (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_1)) )))) != 0);
+  if (__pyx_t_2) {
+
+    /* "beam_calc.pyx":260
+ *     cdef int_t r = values.shape[0]
+ *     if x < values[0]:
+ *         return 0             # <<<<<<<<<<<<<<
+ *     elif x > values[r - 1]:
+ *         return r
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "beam_calc.pyx":259
+ * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:
+ *     cdef int_t r = values.shape[0]
+ *     if x < values[0]:             # <<<<<<<<<<<<<<
+ *         return 0
+ *     elif x > values[r - 1]:
  */
-  __pyx_t_1 = 0;
-  __pyx_t_2 = (__pyx_v_k - (__pyx_v_b / 2));
-  if (((__pyx_t_1 > __pyx_t_2) != 0)) {
-    __pyx_t_3 = __pyx_t_1;
-  } else {
-    __pyx_t_3 = __pyx_t_2;
-  }
-  __pyx_v_i0 = __pyx_t_3;
-  __pyx_t_3 = __pyx_v_a;
-  __pyx_t_2 = ((__pyx_v_k - (__pyx_v_b / 2)) + __pyx_v_b);
-  if (((__pyx_t_3 < __pyx_t_2) != 0)) {
-    __pyx_t_4 = __pyx_t_3;
-  } else {
-    __pyx_t_4 = __pyx_t_2;
   }
-  __pyx_v_i1 = __pyx_t_4;
 
-  /* "beam_calc.pyx":305
- *         int_t a = a1.shape[0], b = a2.shape[0]
- *         int_t i0 = max(k - b // 2, 0), i1 = min(k - b//2 + b, a), i
- *         float_t x = 0             # <<<<<<<<<<<<<<
- *     for i in range(i0, i1):
- *         x += a1[i] * a2[k + b//2 - i]
+  /* "beam_calc.pyx":261
+ *     if x < values[0]:
+ *         return 0
+ *     elif x > values[r - 1]:             # <<<<<<<<<<<<<<
+ *         return r
+ *     else:
  */
-  __pyx_v_x = 0.0;
+  __pyx_t_3 = (__pyx_v_r - 1);
+  __pyx_t_2 = ((__pyx_v_x > (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_values.data) + __pyx_t_3)) )))) != 0);
+  if (__pyx_t_2) {
 
-  /* "beam_calc.pyx":306
- *         int_t i0 = max(k - b // 2, 0), i1 = min(k - b//2 + b, a), i
- *         float_t x = 0
- *     for i in range(i0, i1):             # <<<<<<<<<<<<<<
- *         x += a1[i] * a2[k + b//2 - i]
- *     return x
+    /* "beam_calc.pyx":262
+ *         return 0
+ *     elif x > values[r - 1]:
+ *         return r             # <<<<<<<<<<<<<<
+ *     else:
+ *         return binary_search(values, 0, r, x)
  */
-  __pyx_t_4 = __pyx_v_i1;
-  __pyx_t_3 = __pyx_t_4;
-  for (__pyx_t_2 = __pyx_v_i0; __pyx_t_2 < __pyx_t_3; __pyx_t_2+=1) {
-    __pyx_v_i = __pyx_t_2;
+    __pyx_r = __pyx_v_r;
+    goto __pyx_L0;
 
-    /* "beam_calc.pyx":307
- *         float_t x = 0
- *     for i in range(i0, i1):
- *         x += a1[i] * a2[k + b//2 - i]             # <<<<<<<<<<<<<<
- *     return x
- * 
+    /* "beam_calc.pyx":261
+ *     if x < values[0]:
+ *         return 0
+ *     elif x > values[r - 1]:             # <<<<<<<<<<<<<<
+ *         return r
+ *     else:
  */
-    __pyx_t_5 = __pyx_v_i;
-    __pyx_t_6 = ((__pyx_v_k + (__pyx_v_b / 2)) - __pyx_v_i);
-    __pyx_v_x = (__pyx_v_x + ((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_a1.data) + __pyx_t_5)) ))) * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_a2.data) + __pyx_t_6)) )))));
   }
 
-  /* "beam_calc.pyx":308
- *     for i in range(i0, i1):
- *         x += a1[i] * a2[k + b//2 - i]
- *     return x             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":264
+ *         return r
+ *     else:
+ *         return binary_search(values, 0, r, x)             # <<<<<<<<<<<<<<
  * 
- * cdef void make_frame_c(uint_t[:, ::1] frame, float_t[::1] i_x, float_t[::1] i_y,
+ * cdef void barcode_c(float_t[::1] br_tr, float_t[::1] x_arr, float_t[::1] bx_arr,
  */
-  __pyx_r = __pyx_v_x;
-  goto __pyx_L0;
+  /*else*/ {
+    __pyx_r = __pyx_f_9beam_calc_binary_search(__pyx_v_values, 0, __pyx_v_r, __pyx_v_x);
+    goto __pyx_L0;
+  }
 
-  /* "beam_calc.pyx":301
- *     return np.asarray(bc_t)
+  /* "beam_calc.pyx":257
+ *             return binary_search(values, m + 1, r, x)
  * 
- * cdef float_t convolve_c(float_t[::1] a1, float_t[::1] a2, int_t k) nogil:             # <<<<<<<<<<<<<<
- *     cdef:
- *         int_t a = a1.shape[0], b = a2.shape[0]
+ * cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:             # <<<<<<<<<<<<<<
+ *     cdef int_t r = values.shape[0]
+ *     if x < values[0]:
  */
 
   /* function exit code */
@@ -7459,149 +6606,244 @@ static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_convolve_c(__Pyx_memviewsli
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":310
- *     return x
+/* "beam_calc.pyx":266
+ *         return binary_search(values, 0, r, x)
  * 
- * cdef void make_frame_c(uint_t[:, ::1] frame, float_t[::1] i_x, float_t[::1] i_y,             # <<<<<<<<<<<<<<
- *                        float_t[::1] sc, float_t pix_size, unsigned long seed) nogil:
+ * cdef void barcode_c(float_t[::1] br_tr, float_t[::1] x_arr, float_t[::1] bx_arr,             # <<<<<<<<<<<<<<
+ *                      float_t sgm, float_t atn0, float_t atn, float_t step) nogil:
  *     cdef:
  */
 
-static void __pyx_f_9beam_calc_make_frame_c(__Pyx_memviewslice __pyx_v_frame, __Pyx_memviewslice __pyx_v_i_x, __Pyx_memviewslice __pyx_v_i_y, __Pyx_memviewslice __pyx_v_sc, __pyx_t_9beam_calc_float_t __pyx_v_pix_size, unsigned long __pyx_v_seed) {
+static void __pyx_f_9beam_calc_barcode_c(__Pyx_memviewslice __pyx_v_br_tr, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_bx_arr, __pyx_t_9beam_calc_float_t __pyx_v_sgm, __pyx_t_9beam_calc_float_t __pyx_v_atn0, __pyx_t_9beam_calc_float_t __pyx_v_atn, __pyx_t_9beam_calc_float_t __pyx_v_step) {
+  __pyx_t_9beam_calc_int_t __pyx_v_a;
   __pyx_t_9beam_calc_int_t __pyx_v_b;
-  __pyx_t_9beam_calc_int_t __pyx_v_c;
+  __pyx_t_9beam_calc_int_t __pyx_v_i;
+  __pyx_t_9beam_calc_int_t __pyx_v_j0;
   __pyx_t_9beam_calc_int_t __pyx_v_j;
-  __pyx_t_9beam_calc_int_t __pyx_v_k;
-  gsl_rng *__pyx_v_r;
-  __pyx_t_9beam_calc_float_t __pyx_v_i_xs;
+  __pyx_t_9beam_calc_float_t __pyx_v_br_dx;
+  __pyx_t_9beam_calc_int_t __pyx_v_bb;
+  __pyx_t_9beam_calc_float_t __pyx_v_tr;
+  __pyx_t_9beam_calc_float_t __pyx_v_xx;
+  __pyx_t_9beam_calc_float_t __pyx_v_x0;
+  __pyx_t_9beam_calc_float_t __pyx_v_x1;
   __pyx_t_9beam_calc_int_t __pyx_t_1;
-  __pyx_t_9beam_calc_int_t __pyx_t_2;
+  Py_ssize_t __pyx_t_2;
   __pyx_t_9beam_calc_int_t __pyx_t_3;
   __pyx_t_9beam_calc_int_t __pyx_t_4;
   __pyx_t_9beam_calc_int_t __pyx_t_5;
   __pyx_t_9beam_calc_int_t __pyx_t_6;
   __pyx_t_9beam_calc_int_t __pyx_t_7;
-  __pyx_t_9beam_calc_int_t __pyx_t_8;
-  __pyx_t_9beam_calc_int_t __pyx_t_9;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  __pyx_t_9beam_calc_int_t __pyx_t_10;
 
-  /* "beam_calc.pyx":313
- *                        float_t[::1] sc, float_t pix_size, unsigned long seed) nogil:
+  /* "beam_calc.pyx":269
+ *                      float_t sgm, float_t atn0, float_t atn, float_t step) nogil:
  *     cdef:
- *         int_t b = i_y.shape[0], c = i_x.shape[0], j, k             # <<<<<<<<<<<<<<
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
- *         float_t i_xs
+ *         int_t a = x_arr.shape[0], b = bx_arr.shape[0], i, j0, j             # <<<<<<<<<<<<<<
+ *         float_t br_dx = (bx_arr[b - 1] - bx_arr[0]) / b
+ *         int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)
  */
-  __pyx_v_b = (__pyx_v_i_y.shape[0]);
-  __pyx_v_c = (__pyx_v_i_x.shape[0]);
+  __pyx_v_a = (__pyx_v_x_arr.shape[0]);
+  __pyx_v_b = (__pyx_v_bx_arr.shape[0]);
 
-  /* "beam_calc.pyx":314
+  /* "beam_calc.pyx":270
  *     cdef:
- *         int_t b = i_y.shape[0], c = i_x.shape[0], j, k
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)             # <<<<<<<<<<<<<<
- *         float_t i_xs
- *     gsl_rng_set(r, seed)
+ *         int_t a = x_arr.shape[0], b = bx_arr.shape[0], i, j0, j
+ *         float_t br_dx = (bx_arr[b - 1] - bx_arr[0]) / b             # <<<<<<<<<<<<<<
+ *         int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)
+ *         float_t tr, xx, x0, x1
  */
-  __pyx_v_r = gsl_rng_alloc(gsl_rng_mt19937);
+  __pyx_t_1 = (__pyx_v_b - 1);
+  __pyx_t_2 = 0;
+  __pyx_v_br_dx = (((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_1)) ))) - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_2)) )))) / ((__pyx_t_9beam_calc_float_t)__pyx_v_b));
 
-  /* "beam_calc.pyx":316
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
- *         float_t i_xs
- *     gsl_rng_set(r, seed)             # <<<<<<<<<<<<<<
- *     for k in range(c):
- *         i_xs = convolve_c(i_x, sc, k)
+  /* "beam_calc.pyx":271
+ *         int_t a = x_arr.shape[0], b = bx_arr.shape[0], i, j0, j
+ *         float_t br_dx = (bx_arr[b - 1] - bx_arr[0]) / b
+ *         int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)             # <<<<<<<<<<<<<<
+ *         float_t tr, xx, x0, x1
+ *     for i in range(a):
  */
-  gsl_rng_set(__pyx_v_r, __pyx_v_seed);
+  __pyx_v_bb = ((__pyx_t_9beam_calc_int_t)((((4.320005384913445 * sqrt(2.0)) * __pyx_v_sgm) / __pyx_v_br_dx) + 1.0));
 
-  /* "beam_calc.pyx":317
- *         float_t i_xs
- *     gsl_rng_set(r, seed)
- *     for k in range(c):             # <<<<<<<<<<<<<<
- *         i_xs = convolve_c(i_x, sc, k)
- *         for j in range(b):
+  /* "beam_calc.pyx":273
+ *         int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)
+ *         float_t tr, xx, x0, x1
+ *     for i in range(a):             # <<<<<<<<<<<<<<
+ *         xx = x_arr[i] + step
+ *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'
  */
-  __pyx_t_1 = __pyx_v_c;
-  __pyx_t_2 = __pyx_t_1;
-  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
-    __pyx_v_k = __pyx_t_3;
+  __pyx_t_1 = __pyx_v_a;
+  __pyx_t_3 = __pyx_t_1;
+  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+    __pyx_v_i = __pyx_t_4;
 
-    /* "beam_calc.pyx":318
- *     gsl_rng_set(r, seed)
- *     for k in range(c):
- *         i_xs = convolve_c(i_x, sc, k)             # <<<<<<<<<<<<<<
- *         for j in range(b):
- *             frame[j, k] = gsl_ran_poisson(r, i_xs * i_y[j] * pix_size**2)
+    /* "beam_calc.pyx":274
+ *         float_t tr, xx, x0, x1
+ *     for i in range(a):
+ *         xx = x_arr[i] + step             # <<<<<<<<<<<<<<
+ *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'
+ *         tr = 0
  */
-    __pyx_v_i_xs = __pyx_f_9beam_calc_convolve_c(__pyx_v_i_x, __pyx_v_sc, __pyx_v_k);
+    __pyx_t_5 = __pyx_v_i;
+    __pyx_v_xx = ((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_x_arr.data) + __pyx_t_5)) ))) + __pyx_v_step);
 
-    /* "beam_calc.pyx":319
- *     for k in range(c):
- *         i_xs = convolve_c(i_x, sc, k)
- *         for j in range(b):             # <<<<<<<<<<<<<<
- *             frame[j, k] = gsl_ran_poisson(r, i_xs * i_y[j] * pix_size**2)
- *     gsl_rng_free(r)
+    /* "beam_calc.pyx":275
+ *     for i in range(a):
+ *         xx = x_arr[i] + step
+ *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'             # <<<<<<<<<<<<<<
+ *         tr = 0
+ *         for j in range(j0 - bb, j0 + bb + 1):
  */
-    __pyx_t_4 = __pyx_v_b;
-    __pyx_t_5 = __pyx_t_4;
-    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
-      __pyx_v_j = __pyx_t_6;
+    __pyx_v_j0 = __pyx_f_9beam_calc_searchsorted(__pyx_v_bx_arr, __pyx_v_xx);
 
-      /* "beam_calc.pyx":320
- *         i_xs = convolve_c(i_x, sc, k)
- *         for j in range(b):
- *             frame[j, k] = gsl_ran_poisson(r, i_xs * i_y[j] * pix_size**2)             # <<<<<<<<<<<<<<
- *     gsl_rng_free(r)
- * 
+    /* "beam_calc.pyx":276
+ *         xx = x_arr[i] + step
+ *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'
+ *         tr = 0             # <<<<<<<<<<<<<<
+ *         for j in range(j0 - bb, j0 + bb + 1):
+ *             if j >= 1 and j < b:
  */
-      __pyx_t_7 = __pyx_v_j;
-      __pyx_t_8 = __pyx_v_j;
-      __pyx_t_9 = __pyx_v_k;
-      *((__pyx_t_9beam_calc_uint_t *) ( /* dim=1 */ ((char *) (((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_frame.data + __pyx_t_8 * __pyx_v_frame.strides[0]) )) + __pyx_t_9)) )) = gsl_ran_poisson(__pyx_v_r, ((__pyx_v_i_xs * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_i_y.data) + __pyx_t_7)) )))) * pow(__pyx_v_pix_size, 2.0)));
+    __pyx_v_tr = 0.0;
+
+    /* "beam_calc.pyx":277
+ *         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'
+ *         tr = 0
+ *         for j in range(j0 - bb, j0 + bb + 1):             # <<<<<<<<<<<<<<
+ *             if j >= 1 and j < b:
+ *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
+ */
+    __pyx_t_5 = ((__pyx_v_j0 + __pyx_v_bb) + 1);
+    __pyx_t_6 = __pyx_t_5;
+    for (__pyx_t_7 = (__pyx_v_j0 - __pyx_v_bb); __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+      __pyx_v_j = __pyx_t_7;
+
+      /* "beam_calc.pyx":278
+ *         tr = 0
+ *         for j in range(j0 - bb, j0 + bb + 1):
+ *             if j >= 1 and j < b:             # <<<<<<<<<<<<<<
+ *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
+ *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
+ */
+      __pyx_t_9 = ((__pyx_v_j >= 1) != 0);
+      if (__pyx_t_9) {
+      } else {
+        __pyx_t_8 = __pyx_t_9;
+        goto __pyx_L8_bool_binop_done;
+      }
+      __pyx_t_9 = ((__pyx_v_j < __pyx_v_b) != 0);
+      __pyx_t_8 = __pyx_t_9;
+      __pyx_L8_bool_binop_done:;
+      if (__pyx_t_8) {
+
+        /* "beam_calc.pyx":279
+ *         for j in range(j0 - bb, j0 + bb + 1):
+ *             if j >= 1 and j < b:
+ *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm             # <<<<<<<<<<<<<<
+ *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
+ *                 tr += atn * 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))
+ */
+        __pyx_t_10 = (__pyx_v_j - 1);
+        __pyx_v_x0 = (((__pyx_v_xx - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_10)) )))) / ((__pyx_t_9beam_calc_float_t)sqrt(2.0))) / __pyx_v_sgm);
+
+        /* "beam_calc.pyx":280
+ *             if j >= 1 and j < b:
+ *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
+ *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm             # <<<<<<<<<<<<<<
+ *                 tr += atn * 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))
+ *         tr -= (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[0]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)
+ */
+        __pyx_t_10 = __pyx_v_j;
+        __pyx_v_x1 = (((__pyx_v_xx - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_10)) )))) / ((__pyx_t_9beam_calc_float_t)sqrt(2.0))) / __pyx_v_sgm);
+
+        /* "beam_calc.pyx":281
+ *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
+ *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
+ *                 tr += atn * 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))             # <<<<<<<<<<<<<<
+ *         tr -= (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[0]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)
+ *         tr += (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[b - 1]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)
+ */
+        __pyx_v_tr = (__pyx_v_tr + (((__pyx_v_atn * 0.5) * (0.5 - (__pyx_v_j % 2))) * (erf(__pyx_v_x0) - erf(__pyx_v_x1))));
+
+        /* "beam_calc.pyx":278
+ *         tr = 0
+ *         for j in range(j0 - bb, j0 + bb + 1):
+ *             if j >= 1 and j < b:             # <<<<<<<<<<<<<<
+ *                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
+ *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
+ */
+      }
     }
-  }
 
-  /* "beam_calc.pyx":321
- *         for j in range(b):
- *             frame[j, k] = gsl_ran_poisson(r, i_xs * i_y[j] * pix_size**2)
- *     gsl_rng_free(r)             # <<<<<<<<<<<<<<
+    /* "beam_calc.pyx":282
+ *                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
+ *                 tr += atn * 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))
+ *         tr -= (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[0]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)             # <<<<<<<<<<<<<<
+ *         tr += (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[b - 1]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)
+ *         br_tr[i] = sqrt(1 + tr)
+ */
+    __pyx_t_2 = 0;
+    __pyx_v_tr = (__pyx_v_tr - (((0.25 * __pyx_v_atn) + (0.5 * __pyx_v_atn0)) * erf((((__pyx_v_xx - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_2)) )))) / ((__pyx_t_9beam_calc_float_t)sqrt((2.0 + (2.0 * pow((__pyx_v_atn0 / __pyx_v_atn), 2.0)))))) / __pyx_v_sgm))));
+
+    /* "beam_calc.pyx":283
+ *                 tr += atn * 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))
+ *         tr -= (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[0]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)
+ *         tr += (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[b - 1]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)             # <<<<<<<<<<<<<<
+ *         br_tr[i] = sqrt(1 + tr)
+ * 
+ */
+    __pyx_t_5 = (__pyx_v_b - 1);
+    __pyx_v_tr = (__pyx_v_tr + (((0.25 * __pyx_v_atn) + (0.5 * __pyx_v_atn0)) * erf((((__pyx_v_xx - (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_bx_arr.data) + __pyx_t_5)) )))) / ((__pyx_t_9beam_calc_float_t)sqrt((2.0 + (2.0 * pow((__pyx_v_atn0 / __pyx_v_atn), 2.0)))))) / __pyx_v_sgm))));
+
+    /* "beam_calc.pyx":284
+ *         tr -= (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[0]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)
+ *         tr += (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[b - 1]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)
+ *         br_tr[i] = sqrt(1 + tr)             # <<<<<<<<<<<<<<
  * 
- * def make_frames(float_t[:, ::1] i_x, float_t[::1] i_y, float_t[::1] sc_x, float_t[::1] sc_y, float_t pix_size):
+ * def barcode_1d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn0, float_t atn):
  */
-  gsl_rng_free(__pyx_v_r);
+    __pyx_t_5 = __pyx_v_i;
+    *((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_br_tr.data) + __pyx_t_5)) )) = sqrt((1.0 + __pyx_v_tr));
+  }
 
-  /* "beam_calc.pyx":310
- *     return x
+  /* "beam_calc.pyx":266
+ *         return binary_search(values, 0, r, x)
  * 
- * cdef void make_frame_c(uint_t[:, ::1] frame, float_t[::1] i_x, float_t[::1] i_y,             # <<<<<<<<<<<<<<
- *                        float_t[::1] sc, float_t pix_size, unsigned long seed) nogil:
+ * cdef void barcode_c(float_t[::1] br_tr, float_t[::1] x_arr, float_t[::1] bx_arr,             # <<<<<<<<<<<<<<
+ *                      float_t sgm, float_t atn0, float_t atn, float_t step) nogil:
  *     cdef:
  */
 
   /* function exit code */
 }
 
-/* "beam_calc.pyx":323
- *     gsl_rng_free(r)
+/* "beam_calc.pyx":286
+ *         br_tr[i] = sqrt(1 + tr)
  * 
- * def make_frames(float_t[:, ::1] i_x, float_t[::1] i_y, float_t[::1] sc_x, float_t[::1] sc_y, float_t pix_size):             # <<<<<<<<<<<<<<
+ * def barcode_1d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn0, float_t atn):             # <<<<<<<<<<<<<<
  *     """
- *     Generate intensity frames with Poisson noise from x and y coordinate wavefront profiles
+ *     Barcode transmission array for a scan
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_17make_frames(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_16make_frames[] = "\n    Generate intensity frames with Poisson noise from x and y coordinate wavefront profiles\n\n    i_x, i_y - x and y coordinate intensity profiles\n    sc_x, sc_y - source rocking curve along x- and y-axes\n    pix_size - pixel size [um]\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_17make_frames = {"make_frames", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_17make_frames, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_16make_frames};
-static PyObject *__pyx_pw_9beam_calc_17make_frames(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  __Pyx_memviewslice __pyx_v_i_x = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_i_y = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_sc_x = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_sc_y = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_float_t __pyx_v_pix_size;
+static PyObject *__pyx_pw_9beam_calc_15barcode_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_14barcode_1d[] = "\n    Barcode transmission array for a scan\n\n    x_arr - coordinates [um]\n    bx_arr - bar coordinates array [um]\n    sgm - bar haziness width [um]\n    atn0, atn - bulk and bar attenuation (0.0 - 1.0)\n    ss - scan step size [um]\n    nf - number of frames of a scan\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_15barcode_1d = {"barcode_1d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_15barcode_1d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_14barcode_1d};
+static PyObject *__pyx_pw_9beam_calc_15barcode_1d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_bx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_float_t __pyx_v_sgm;
+  __pyx_t_9beam_calc_float_t __pyx_v_atn0;
+  __pyx_t_9beam_calc_float_t __pyx_v_atn;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("make_frames (wrapper)", 0);
+  __Pyx_RefNannySetupContext("barcode_1d (wrapper)", 0);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i_x,&__pyx_n_s_i_y,&__pyx_n_s_sc_x,&__pyx_n_s_sc_y,&__pyx_n_s_pix_size,0};
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_arr,&__pyx_n_s_bx_arr,&__pyx_n_s_sgm,&__pyx_n_s_atn0,&__pyx_n_s_atn,0};
     PyObject* values[5] = {0,0,0,0,0};
     if (unlikely(__pyx_kwds)) {
       Py_ssize_t kw_args;
@@ -7623,35 +6865,35 @@ static PyObject *__pyx_pw_9beam_calc_17make_frames(PyObject *__pyx_self, PyObjec
       kw_args = PyDict_Size(__pyx_kwds);
       switch (pos_args) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i_x)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_arr)) != 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_i_y)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bx_arr)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, 1); __PYX_ERR(0, 323, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("barcode_1d", 1, 5, 5, 1); __PYX_ERR(0, 286, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sc_x)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sgm)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, 2); __PYX_ERR(0, 323, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("barcode_1d", 1, 5, 5, 2); __PYX_ERR(0, 286, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sc_y)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atn0)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, 3); __PYX_ERR(0, 323, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("barcode_1d", 1, 5, 5, 3); __PYX_ERR(0, 286, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pix_size)) != 0)) kw_args--;
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atn)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, 4); __PYX_ERR(0, 323, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("barcode_1d", 1, 5, 5, 4); __PYX_ERR(0, 286, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_frames") < 0)) __PYX_ERR(0, 323, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "barcode_1d") < 0)) __PYX_ERR(0, 286, __pyx_L3_error)
       }
     } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
       goto __pyx_L5_argtuple_error;
@@ -7662,36 +6904,30 @@ static PyObject *__pyx_pw_9beam_calc_17make_frames(PyObject *__pyx_self, PyObjec
       values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
       values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
     }
-    __pyx_v_i_x = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_i_x.memview)) __PYX_ERR(0, 323, __pyx_L3_error)
-    __pyx_v_i_y = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_i_y.memview)) __PYX_ERR(0, 323, __pyx_L3_error)
-    __pyx_v_sc_x = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_sc_x.memview)) __PYX_ERR(0, 323, __pyx_L3_error)
-    __pyx_v_sc_y = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_sc_y.memview)) __PYX_ERR(0, 323, __pyx_L3_error)
-    __pyx_v_pix_size = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_pix_size == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 323, __pyx_L3_error)
+    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 286, __pyx_L3_error)
+    __pyx_v_bx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_bx_arr.memview)) __PYX_ERR(0, 286, __pyx_L3_error)
+    __pyx_v_sgm = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_sgm == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 286, __pyx_L3_error)
+    __pyx_v_atn0 = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_atn0 == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 286, __pyx_L3_error)
+    __pyx_v_atn = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_atn == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 286, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 323, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("barcode_1d", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 286, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("beam_calc.make_frames", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("beam_calc.barcode_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_16make_frames(__pyx_self, __pyx_v_i_x, __pyx_v_i_y, __pyx_v_sc_x, __pyx_v_sc_y, __pyx_v_pix_size);
+  __pyx_r = __pyx_pf_9beam_calc_14barcode_1d(__pyx_self, __pyx_v_x_arr, __pyx_v_bx_arr, __pyx_v_sgm, __pyx_v_atn0, __pyx_v_atn);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_9beam_calc_16make_frames(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_i_x, __Pyx_memviewslice __pyx_v_i_y, __Pyx_memviewslice __pyx_v_sc_x, __Pyx_memviewslice __pyx_v_sc_y, __pyx_t_9beam_calc_float_t __pyx_v_pix_size) {
+static PyObject *__pyx_pf_9beam_calc_14barcode_1d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_bx_arr, __pyx_t_9beam_calc_float_t __pyx_v_sgm, __pyx_t_9beam_calc_float_t __pyx_v_atn0, __pyx_t_9beam_calc_float_t __pyx_v_atn) {
   __pyx_t_9beam_calc_int_t __pyx_v_a;
-  __pyx_t_9beam_calc_int_t __pyx_v_b;
-  __pyx_t_9beam_calc_int_t __pyx_v_c;
-  __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __Pyx_memviewslice __pyx_v_frames = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_i_ys = { 0, 0, { 0 }, { 0 }, { 0 } };
-  gsl_rng *__pyx_v_r;
-  unsigned long __pyx_v_seed;
+  __Pyx_memviewslice __pyx_v_br_tr = { 0, 0, { 0 }, { 0 }, { 0 } };
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
@@ -7700,156 +6936,344 @@ static PyObject *__pyx_pf_9beam_calc_16make_frames(CYTHON_UNUSED PyObject *__pyx
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
   __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_t_7 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_int_t __pyx_t_8;
-  __pyx_t_9beam_calc_int_t __pyx_t_9;
-  __pyx_t_9beam_calc_int_t __pyx_t_10;
-  __pyx_t_9beam_calc_int_t __pyx_t_11;
-  __Pyx_memviewslice __pyx_t_12 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_RefNannySetupContext("make_frames", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("barcode_1d", 0);
 
-  /* "beam_calc.pyx":332
+  /* "beam_calc.pyx":298
  *     """
  *     cdef:
- *         int_t a = i_x.shape[0], b = i_y.shape[0], c = i_x.shape[1], i             # <<<<<<<<<<<<<<
- *         uint_t[:, :, ::1] frames = np.empty((a, b, c), dtype=np.uint64)
- *         float_t[::1] i_ys = np.empty(b, dtype=np.float64)
+ *         int_t a = x_arr.shape[0]             # <<<<<<<<<<<<<<
+ *         float_t[::1] br_tr = np.empty(a, dtype=np.float64)
+ *     barcode_c(br_tr, x_arr, bx_arr, sgm, atn0, atn, 0)
  */
-  __pyx_v_a = (__pyx_v_i_x.shape[0]);
-  __pyx_v_b = (__pyx_v_i_y.shape[0]);
-  __pyx_v_c = (__pyx_v_i_x.shape[1]);
+  __pyx_v_a = (__pyx_v_x_arr.shape[0]);
 
-  /* "beam_calc.pyx":333
+  /* "beam_calc.pyx":299
  *     cdef:
- *         int_t a = i_x.shape[0], b = i_y.shape[0], c = i_x.shape[1], i
- *         uint_t[:, :, ::1] frames = np.empty((a, b, c), dtype=np.uint64)             # <<<<<<<<<<<<<<
- *         float_t[::1] i_ys = np.empty(b, dtype=np.float64)
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
+ *         int_t a = x_arr.shape[0]
+ *         float_t[::1] br_tr = np.empty(a, dtype=np.float64)             # <<<<<<<<<<<<<<
+ *     barcode_c(br_tr, x_arr, bx_arr, sgm, atn0, atn, 0)
+ *     return np.asarray(br_tr)
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 299, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyInt_From_npy_int64(__pyx_v_c); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 333, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 333, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
   __pyx_t_1 = 0;
-  __pyx_t_3 = 0;
-  __pyx_t_4 = 0;
-  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 299, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GIVEREF(__pyx_t_5);
-  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
-  __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float64); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 299, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_uint64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 333, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 299, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_9beam_calc_uint_t(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_frames = __pyx_t_6;
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 299, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_br_tr = __pyx_t_6;
   __pyx_t_6.memview = NULL;
   __pyx_t_6.data = NULL;
 
-  /* "beam_calc.pyx":334
- *         int_t a = i_x.shape[0], b = i_y.shape[0], c = i_x.shape[1], i
- *         uint_t[:, :, ::1] frames = np.empty((a, b, c), dtype=np.uint64)
- *         float_t[::1] i_ys = np.empty(b, dtype=np.float64)             # <<<<<<<<<<<<<<
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
- *         unsigned long seed
+  /* "beam_calc.pyx":300
+ *         int_t a = x_arr.shape[0]
+ *         float_t[::1] br_tr = np.empty(a, dtype=np.float64)
+ *     barcode_c(br_tr, x_arr, bx_arr, sgm, atn0, atn, 0)             # <<<<<<<<<<<<<<
+ *     return np.asarray(br_tr)
+ * 
+ */
+  __pyx_f_9beam_calc_barcode_c(__pyx_v_br_tr, __pyx_v_x_arr, __pyx_v_bx_arr, __pyx_v_sgm, __pyx_v_atn0, __pyx_v_atn, 0.0);
+
+  /* "beam_calc.pyx":301
+ *         float_t[::1] br_tr = np.empty(a, dtype=np.float64)
+ *     barcode_c(br_tr, x_arr, bx_arr, sgm, atn0, atn, 0)
+ *     return np.asarray(br_tr)             # <<<<<<<<<<<<<<
+ * 
+ * def barcode_2d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm,
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_br_tr, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_9beam_calc_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_9beam_calc_float_t, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(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_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 301, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "beam_calc.pyx":286
+ *         br_tr[i] = sqrt(1 + tr)
+ * 
+ * def barcode_1d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn0, float_t atn):             # <<<<<<<<<<<<<<
+ *     """
+ *     Barcode transmission array for a scan
+ */
+
+  /* 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_6, 1);
+  __Pyx_AddTraceback("beam_calc.barcode_1d", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __PYX_XDEC_MEMVIEW(&__pyx_v_br_tr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_bx_arr, 1);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":303
+ *     return np.asarray(br_tr)
+ * 
+ * def barcode_2d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm,             # <<<<<<<<<<<<<<
+ *                float_t atn0, float_t atn, float_t ss, int_t nf):
+ *     """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9beam_calc_17barcode_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_16barcode_2d[] = "\n    Barcode transmission array for a scan\n\n    x_arr - coordinates [um]\n    bx_arr - bar coordinates array [um]\n    sgm - bar haziness width [um]\n    atn0, atn - bulk and bar attenuation (0.0 - 1.0)\n    ss - scan step size [um]\n    nf - number of frames of a scan\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_17barcode_2d = {"barcode_2d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_17barcode_2d, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_16barcode_2d};
+static PyObject *__pyx_pw_9beam_calc_17barcode_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __Pyx_memviewslice __pyx_v_x_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_bx_arr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_float_t __pyx_v_sgm;
+  __pyx_t_9beam_calc_float_t __pyx_v_atn0;
+  __pyx_t_9beam_calc_float_t __pyx_v_atn;
+  __pyx_t_9beam_calc_float_t __pyx_v_ss;
+  __pyx_t_9beam_calc_int_t __pyx_v_nf;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("barcode_2d (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_arr,&__pyx_n_s_bx_arr,&__pyx_n_s_sgm,&__pyx_n_s_atn0,&__pyx_n_s_atn,&__pyx_n_s_ss,&__pyx_n_s_nf,0};
+    PyObject* values[7] = {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  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_x_arr)) != 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_bx_arr)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("barcode_2d", 1, 7, 7, 1); __PYX_ERR(0, 303, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sgm)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("barcode_2d", 1, 7, 7, 2); __PYX_ERR(0, 303, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atn0)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("barcode_2d", 1, 7, 7, 3); __PYX_ERR(0, 303, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atn)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("barcode_2d", 1, 7, 7, 4); __PYX_ERR(0, 303, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  5:
+        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ss)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("barcode_2d", 1, 7, 7, 5); __PYX_ERR(0, 303, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  6:
+        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nf)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("barcode_2d", 1, 7, 7, 6); __PYX_ERR(0, 303, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "barcode_2d") < 0)) __PYX_ERR(0, 303, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 7) {
+      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);
+    }
+    __pyx_v_x_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_arr.memview)) __PYX_ERR(0, 303, __pyx_L3_error)
+    __pyx_v_bx_arr = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_bx_arr.memview)) __PYX_ERR(0, 303, __pyx_L3_error)
+    __pyx_v_sgm = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_sgm == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 303, __pyx_L3_error)
+    __pyx_v_atn0 = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_atn0 == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 304, __pyx_L3_error)
+    __pyx_v_atn = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_atn == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 304, __pyx_L3_error)
+    __pyx_v_ss = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_ss == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 304, __pyx_L3_error)
+    __pyx_v_nf = __Pyx_PyInt_As_npy_int64(values[6]); if (unlikely((__pyx_v_nf == ((npy_int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 304, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("barcode_2d", 1, 7, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 303, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("beam_calc.barcode_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_9beam_calc_16barcode_2d(__pyx_self, __pyx_v_x_arr, __pyx_v_bx_arr, __pyx_v_sgm, __pyx_v_atn0, __pyx_v_atn, __pyx_v_ss, __pyx_v_nf);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9beam_calc_16barcode_2d(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_arr, __Pyx_memviewslice __pyx_v_bx_arr, __pyx_t_9beam_calc_float_t __pyx_v_sgm, __pyx_t_9beam_calc_float_t __pyx_v_atn0, __pyx_t_9beam_calc_float_t __pyx_v_atn, __pyx_t_9beam_calc_float_t __pyx_v_ss, __pyx_t_9beam_calc_int_t __pyx_v_nf) {
+  __pyx_t_9beam_calc_int_t __pyx_v_a;
+  __pyx_t_9beam_calc_int_t __pyx_v_i;
+  __Pyx_memviewslice __pyx_v_br_tr = { 0, 0, { 0 }, { 0 }, { 0 } };
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_int_t __pyx_t_7;
+  __pyx_t_9beam_calc_int_t __pyx_t_8;
+  __pyx_t_9beam_calc_int_t __pyx_t_9;
+  __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("barcode_2d", 0);
+
+  /* "beam_calc.pyx":316
+ *     """
+ *     cdef:
+ *         int_t a = x_arr.shape[0], i             # <<<<<<<<<<<<<<
+ *         float_t[:, ::1] br_tr = np.empty((nf, a), dtype=np.float64)
+ *     for i in prange(nf, schedule='guided', nogil=True):
+ */
+  __pyx_v_a = (__pyx_v_x_arr.shape[0]);
+
+  /* "beam_calc.pyx":317
+ *     cdef:
+ *         int_t a = x_arr.shape[0], i
+ *         float_t[:, ::1] br_tr = np.empty((nf, a), dtype=np.float64)             # <<<<<<<<<<<<<<
+ *     for i in prange(nf, schedule='guided', nogil=True):
+ *         barcode_c(br_tr[i], x_arr, bx_arr, sgm, atn0, atn, i * ss)
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 334, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 334, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 334, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_nf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 334, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 317, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_GIVEREF(__pyx_t_1);
   PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
   __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 334, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float64); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L1_error)
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 334, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 334, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_v_i_ys = __pyx_t_7;
-  __pyx_t_7.memview = NULL;
-  __pyx_t_7.data = NULL;
-
-  /* "beam_calc.pyx":335
- *         uint_t[:, :, ::1] frames = np.empty((a, b, c), dtype=np.uint64)
- *         float_t[::1] i_ys = np.empty(b, dtype=np.float64)
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)             # <<<<<<<<<<<<<<
- *         unsigned long seed
- *     for i in range(b):
- */
-  __pyx_v_r = gsl_rng_alloc(gsl_rng_mt19937);
-
-  /* "beam_calc.pyx":337
- *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
- *         unsigned long seed
- *     for i in range(b):             # <<<<<<<<<<<<<<
- *         i_ys[i] = convolve_c(i_y, sc_y, i)
- *     for i in prange(a, schedule='guided', nogil=True):
- */
-  __pyx_t_8 = __pyx_v_b;
-  __pyx_t_9 = __pyx_t_8;
-  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
-    __pyx_v_i = __pyx_t_10;
-
-    /* "beam_calc.pyx":338
- *         unsigned long seed
- *     for i in range(b):
- *         i_ys[i] = convolve_c(i_y, sc_y, i)             # <<<<<<<<<<<<<<
- *     for i in prange(a, schedule='guided', nogil=True):
- *         seed = gsl_rng_get(r)
- */
-    __pyx_t_11 = __pyx_v_i;
-    *((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_i_ys.data) + __pyx_t_11)) )) = __pyx_f_9beam_calc_convolve_c(__pyx_v_i_y, __pyx_v_sc_y, __pyx_v_i);
-  }
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_float_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_br_tr = __pyx_t_6;
+  __pyx_t_6.memview = NULL;
+  __pyx_t_6.data = NULL;
 
-  /* "beam_calc.pyx":339
- *     for i in range(b):
- *         i_ys[i] = convolve_c(i_y, sc_y, i)
- *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         seed = gsl_rng_get(r)
- *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
+  /* "beam_calc.pyx":318
+ *         int_t a = x_arr.shape[0], i
+ *         float_t[:, ::1] br_tr = np.empty((nf, a), dtype=np.float64)
+ *     for i in prange(nf, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         barcode_c(br_tr[i], x_arr, bx_arr, sgm, atn0, atn, i * ss)
+ *     return np.asarray(br_tr)
  */
   {
       #ifdef WITH_THREAD
@@ -7858,174 +7282,56 @@ static PyObject *__pyx_pf_9beam_calc_16make_frames(CYTHON_UNUSED PyObject *__pyx
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
-        __pyx_t_8 = __pyx_v_a;
+        __pyx_t_7 = __pyx_v_nf;
         if ((1 == 0)) abort();
         {
-            __pyx_t_9beam_calc_int_t __pyx_parallel_temp0 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
-            unsigned long __pyx_parallel_temp1 = ((unsigned long)0xbad0bad0);
-            const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0;
-            PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL;
-            int __pyx_parallel_why;
-            __pyx_parallel_why = 0;
             #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                 #undef likely
                 #undef unlikely
                 #define likely(x)   (x)
                 #define unlikely(x) (x)
             #endif
-            __pyx_t_10 = (__pyx_t_8 - 0 + 1 - 1/abs(1)) / 1;
-            if (__pyx_t_10 > 0)
+            __pyx_t_9 = (__pyx_t_7 - 0 + 1 - 1/abs(1)) / 1;
+            if (__pyx_t_9 > 0)
             {
                 #ifdef _OPENMP
-                #pragma omp parallel firstprivate(__pyx_t_12, __pyx_t_7) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb)
+                #pragma omp parallel firstprivate(__pyx_t_10)
                 #endif /* _OPENMP */
                 {
                     #ifdef _OPENMP
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    Py_BEGIN_ALLOW_THREADS
-                    #endif /* _OPENMP */
-                    #ifdef _OPENMP
-                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) lastprivate(__pyx_v_seed) schedule(guided)
+                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) schedule(guided)
                     #endif /* _OPENMP */
-                    for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_10; __pyx_t_9++){
-                        if (__pyx_parallel_why < 2)
+                    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
                         {
-                            __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_9);
-                            /* Initialize private variables to invalid values */
-                            __pyx_v_seed = ((unsigned long)0xbad0bad0);
-
-                            /* "beam_calc.pyx":340
- *         i_ys[i] = convolve_c(i_y, sc_y, i)
- *     for i in prange(a, schedule='guided', nogil=True):
- *         seed = gsl_rng_get(r)             # <<<<<<<<<<<<<<
- *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
- *     gsl_rng_free(r)
- */
-                            __pyx_v_seed = gsl_rng_get(__pyx_v_r);
+                            __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
 
-                            /* "beam_calc.pyx":341
- *     for i in prange(a, schedule='guided', nogil=True):
- *         seed = gsl_rng_get(r)
- *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)             # <<<<<<<<<<<<<<
- *     gsl_rng_free(r)
- *     return np.asarray(frames)
+                            /* "beam_calc.pyx":319
+ *         float_t[:, ::1] br_tr = np.empty((nf, a), dtype=np.float64)
+ *     for i in prange(nf, schedule='guided', nogil=True):
+ *         barcode_c(br_tr[i], x_arr, bx_arr, sgm, atn0, atn, i * ss)             # <<<<<<<<<<<<<<
+ *     return np.asarray(br_tr)
+ * 
  */
-                            __pyx_t_12.data = __pyx_v_frames.data;
-                            __pyx_t_12.memview = __pyx_v_frames.memview;
-                            __PYX_INC_MEMVIEW(&__pyx_t_12, 0);
-                            {
-    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_frames.strides[0];
-        if ((0)) __PYX_ERR(0, 341, __pyx_L10_error)
-        __pyx_t_12.data += __pyx_tmp_idx * __pyx_tmp_stride;
-}
-
-__pyx_t_12.shape[0] = __pyx_v_frames.shape[1];
-__pyx_t_12.strides[0] = __pyx_v_frames.strides[1];
-    __pyx_t_12.suboffsets[0] = -1;
-
-__pyx_t_12.shape[1] = __pyx_v_frames.shape[2];
-__pyx_t_12.strides[1] = __pyx_v_frames.strides[2];
-    __pyx_t_12.suboffsets[1] = -1;
-
-__pyx_t_7.data = __pyx_v_i_x.data;
-                            __pyx_t_7.memview = __pyx_v_i_x.memview;
-                            __PYX_INC_MEMVIEW(&__pyx_t_7, 0);
+                            __pyx_t_10.data = __pyx_v_br_tr.data;
+                            __pyx_t_10.memview = __pyx_v_br_tr.memview;
+                            __PYX_INC_MEMVIEW(&__pyx_t_10, 0);
                             {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_i_x.strides[0];
-        if ((0)) __PYX_ERR(0, 341, __pyx_L10_error)
-        __pyx_t_7.data += __pyx_tmp_idx * __pyx_tmp_stride;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_br_tr.strides[0];
+        __pyx_t_10.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
-__pyx_t_7.shape[0] = __pyx_v_i_x.shape[1];
-__pyx_t_7.strides[0] = __pyx_v_i_x.strides[1];
-    __pyx_t_7.suboffsets[0] = -1;
+__pyx_t_10.shape[0] = __pyx_v_br_tr.shape[1];
+__pyx_t_10.strides[0] = __pyx_v_br_tr.strides[1];
+    __pyx_t_10.suboffsets[0] = -1;
 
-__pyx_f_9beam_calc_make_frame_c(__pyx_t_12, __pyx_t_7, __pyx_v_i_ys, __pyx_v_sc_x, __pyx_v_pix_size, __pyx_v_seed);
-                            __PYX_XDEC_MEMVIEW(&__pyx_t_12, 0);
-                            __pyx_t_12.memview = NULL;
-                            __pyx_t_12.data = NULL;
-                            __PYX_XDEC_MEMVIEW(&__pyx_t_7, 0);
-                            __pyx_t_7.memview = NULL;
-                            __pyx_t_7.data = NULL;
-                            goto __pyx_L13;
-                            __pyx_L10_error:;
-                            {
-                                #ifdef WITH_THREAD
-                                PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                                #endif
-                                #ifdef _OPENMP
-                                #pragma omp flush(__pyx_parallel_exc_type)
-                                #endif /* _OPENMP */
-                                if (!__pyx_parallel_exc_type) {
-                                  __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
-                                  __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
-                                  __Pyx_GOTREF(__pyx_parallel_exc_type);
-                                }
-                                #ifdef WITH_THREAD
-                                __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                                #endif
-                            }
-                            __pyx_parallel_why = 4;
-                            goto __pyx_L12;
-                            __pyx_L12:;
-                            #ifdef _OPENMP
-                            #pragma omp critical(__pyx_parallel_lastprivates3)
-                            #endif /* _OPENMP */
-                            {
-                                __pyx_parallel_temp0 = __pyx_v_i;
-                                __pyx_parallel_temp1 = __pyx_v_seed;
-                            }
-                            __pyx_L13:;
-                            #ifdef _OPENMP
-                            #pragma omp flush(__pyx_parallel_why)
-                            #endif /* _OPENMP */
+__pyx_f_9beam_calc_barcode_c(__pyx_t_10, __pyx_v_x_arr, __pyx_v_bx_arr, __pyx_v_sgm, __pyx_v_atn0, __pyx_v_atn, (__pyx_v_i * __pyx_v_ss));
+                            __PYX_XDEC_MEMVIEW(&__pyx_t_10, 0);
+                            __pyx_t_10.memview = NULL;
+                            __pyx_t_10.data = NULL;
                         }
                     }
-                    #ifdef _OPENMP
-                    Py_END_ALLOW_THREADS
-                    #else
-{
-#ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    #endif /* _OPENMP */
-                    /* Clean up any temporaries */
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_12, 0);
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_7, 0);
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
-                    #ifndef _OPENMP
-}
-#endif /* _OPENMP */
-                }
-            }
-            if (__pyx_parallel_exc_type) {
-              /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
-              __pyx_parallel_why = 4;
-            }
-            if (__pyx_parallel_why) {
-              __pyx_v_i = __pyx_parallel_temp0;
-              __pyx_v_seed = __pyx_parallel_temp1;
-              switch (__pyx_parallel_why) {
-                    case 4:
-                {
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    __Pyx_GIVEREF(__pyx_parallel_exc_type);
-                    __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
-                    __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
                 }
-                goto __pyx_L6_error;
-              }
             }
         }
         #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
@@ -8036,12 +7342,12 @@ __pyx_f_9beam_calc_make_frame_c(__pyx_t_12, __pyx_t_7, __pyx_v_i_ys, __pyx_v_sc_
         #endif
       }
 
-      /* "beam_calc.pyx":339
- *     for i in range(b):
- *         i_ys[i] = convolve_c(i_y, sc_y, i)
- *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         seed = gsl_rng_get(r)
- *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
+      /* "beam_calc.pyx":318
+ *         int_t a = x_arr.shape[0], i
+ *         float_t[:, ::1] br_tr = np.empty((nf, a), dtype=np.float64)
+ *     for i in prange(nf, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         barcode_c(br_tr[i], x_arr, bx_arr, sgm, atn0, atn, i * ss)
+ *     return np.asarray(br_tr)
  */
       /*finally:*/ {
         /*normal exit:*/{
@@ -8049,69 +7355,53 @@ __pyx_f_9beam_calc_make_frame_c(__pyx_t_12, __pyx_t_7, __pyx_v_i_ys, __pyx_v_sc_
           __Pyx_FastGIL_Forget();
           Py_BLOCK_THREADS
           #endif
-          goto __pyx_L7;
-        }
-        __pyx_L6_error: {
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L1_error;
+          goto __pyx_L5;
         }
-        __pyx_L7:;
+        __pyx_L5:;
       }
   }
 
-  /* "beam_calc.pyx":342
- *         seed = gsl_rng_get(r)
- *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
- *     gsl_rng_free(r)             # <<<<<<<<<<<<<<
- *     return np.asarray(frames)
- * 
- */
-  gsl_rng_free(__pyx_v_r);
-
-  /* "beam_calc.pyx":343
- *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
- *     gsl_rng_free(r)
- *     return np.asarray(frames)             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":320
+ *     for i in prange(nf, schedule='guided', nogil=True):
+ *         barcode_c(br_tr[i], x_arr, bx_arr, sgm, atn0, atn, i * ss)
+ *     return np.asarray(br_tr)             # <<<<<<<<<<<<<<
  * 
- * cdef uint_t wirthselect_uint(uint_t[:] array, int k) nogil:
+ * cdef float_t convolve_c(float_t[::1] a1, float_t[::1] a2, int_t k) nogil:
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 343, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_asarray); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 343, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 320, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_frames, 3, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_9beam_calc_uint_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_9beam_calc_uint_t, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 343, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __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_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 320, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_br_tr, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_9beam_calc_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_9beam_calc_float_t, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 320, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(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_4, function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
     }
   }
-  __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 320, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
   goto __pyx_L0;
 
-  /* "beam_calc.pyx":323
- *     gsl_rng_free(r)
+  /* "beam_calc.pyx":303
+ *     return np.asarray(br_tr)
  * 
- * def make_frames(float_t[:, ::1] i_x, float_t[::1] i_y, float_t[::1] sc_x, float_t[::1] sc_y, float_t pix_size):             # <<<<<<<<<<<<<<
+ * def barcode_2d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm,             # <<<<<<<<<<<<<<
+ *                float_t atn0, float_t atn, float_t ss, int_t nf):
  *     """
- *     Generate intensity frames with Poisson noise from x and y coordinate wavefront profiles
  */
 
   /* function exit code */
@@ -8122,258 +7412,288 @@ __pyx_f_9beam_calc_make_frame_c(__pyx_t_12, __pyx_t_7, __pyx_v_i_ys, __pyx_v_sc_
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
   __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_12, 1);
-  __Pyx_AddTraceback("beam_calc.make_frames", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
+  __Pyx_AddTraceback("beam_calc.barcode_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_frames, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_i_ys, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_i_x, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_i_y, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_sc_x, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_sc_y, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_br_tr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_x_arr, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_bx_arr, 1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "beam_calc.pyx":345
- *     return np.asarray(frames)
+/* "beam_calc.pyx":322
+ *     return np.asarray(br_tr)
  * 
- * cdef uint_t wirthselect_uint(uint_t[:] array, int k) nogil:             # <<<<<<<<<<<<<<
+ * cdef float_t convolve_c(float_t[::1] a1, float_t[::1] a2, int_t k) nogil:             # <<<<<<<<<<<<<<
  *     cdef:
- *         int_t l = 0, m = array.shape[0] - 1, i, j
+ *         int_t a = a1.shape[0], b = a2.shape[0]
  */
 
-static __pyx_t_9beam_calc_uint_t __pyx_f_9beam_calc_wirthselect_uint(__Pyx_memviewslice __pyx_v_array, int __pyx_v_k) {
-  __pyx_t_9beam_calc_int_t __pyx_v_l;
-  __pyx_t_9beam_calc_int_t __pyx_v_m;
+static __pyx_t_9beam_calc_float_t __pyx_f_9beam_calc_convolve_c(__Pyx_memviewslice __pyx_v_a1, __Pyx_memviewslice __pyx_v_a2, __pyx_t_9beam_calc_int_t __pyx_v_k) {
+  __pyx_t_9beam_calc_int_t __pyx_v_a;
+  __pyx_t_9beam_calc_int_t __pyx_v_b;
+  __pyx_t_9beam_calc_int_t __pyx_v_i0;
+  __pyx_t_9beam_calc_int_t __pyx_v_i1;
   __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __pyx_t_9beam_calc_int_t __pyx_v_j;
-  __pyx_t_9beam_calc_uint_t __pyx_v_x;
-  __pyx_t_9beam_calc_uint_t __pyx_v_tmp;
-  __pyx_t_9beam_calc_uint_t __pyx_r;
-  int __pyx_t_1;
-  Py_ssize_t __pyx_t_2;
+  __pyx_t_9beam_calc_float_t __pyx_v_x;
+  __pyx_t_9beam_calc_float_t __pyx_r;
+  long __pyx_t_1;
+  __pyx_t_9beam_calc_int_t __pyx_t_2;
   __pyx_t_9beam_calc_int_t __pyx_t_3;
   __pyx_t_9beam_calc_int_t __pyx_t_4;
   __pyx_t_9beam_calc_int_t __pyx_t_5;
   __pyx_t_9beam_calc_int_t __pyx_t_6;
-  __pyx_t_9beam_calc_int_t __pyx_t_7;
-  __pyx_t_9beam_calc_int_t __pyx_t_8;
-  Py_ssize_t __pyx_t_9;
 
-  /* "beam_calc.pyx":347
- * cdef uint_t wirthselect_uint(uint_t[:] array, int k) nogil:
+  /* "beam_calc.pyx":324
+ * cdef float_t convolve_c(float_t[::1] a1, float_t[::1] a2, int_t k) nogil:
  *     cdef:
- *         int_t l = 0, m = array.shape[0] - 1, i, j             # <<<<<<<<<<<<<<
- *         uint_t x, tmp
- *     while l < m:
+ *         int_t a = a1.shape[0], b = a2.shape[0]             # <<<<<<<<<<<<<<
+ *         int_t i0 = max(k - b // 2, 0), i1 = min(k - b//2 + b, a), i
+ *         float_t x = 0
  */
-  __pyx_v_l = 0;
-  __pyx_v_m = ((__pyx_v_array.shape[0]) - 1);
+  __pyx_v_a = (__pyx_v_a1.shape[0]);
+  __pyx_v_b = (__pyx_v_a2.shape[0]);
 
-  /* "beam_calc.pyx":349
- *         int_t l = 0, m = array.shape[0] - 1, i, j
- *         uint_t x, tmp
- *     while l < m:             # <<<<<<<<<<<<<<
- *         x = array[k]
- *         i = l; j = m
+  /* "beam_calc.pyx":325
+ *     cdef:
+ *         int_t a = a1.shape[0], b = a2.shape[0]
+ *         int_t i0 = max(k - b // 2, 0), i1 = min(k - b//2 + b, a), i             # <<<<<<<<<<<<<<
+ *         float_t x = 0
+ *     for i in range(i0, i1):
  */
-  while (1) {
-    __pyx_t_1 = ((__pyx_v_l < __pyx_v_m) != 0);
-    if (!__pyx_t_1) break;
+  __pyx_t_1 = 0;
+  __pyx_t_2 = (__pyx_v_k - (__pyx_v_b / 2));
+  if (((__pyx_t_1 > __pyx_t_2) != 0)) {
+    __pyx_t_3 = __pyx_t_1;
+  } else {
+    __pyx_t_3 = __pyx_t_2;
+  }
+  __pyx_v_i0 = __pyx_t_3;
+  __pyx_t_3 = __pyx_v_a;
+  __pyx_t_2 = ((__pyx_v_k - (__pyx_v_b / 2)) + __pyx_v_b);
+  if (((__pyx_t_3 < __pyx_t_2) != 0)) {
+    __pyx_t_4 = __pyx_t_3;
+  } else {
+    __pyx_t_4 = __pyx_t_2;
+  }
+  __pyx_v_i1 = __pyx_t_4;
 
-    /* "beam_calc.pyx":350
- *         uint_t x, tmp
- *     while l < m:
- *         x = array[k]             # <<<<<<<<<<<<<<
- *         i = l; j = m
- *         while 1:
+  /* "beam_calc.pyx":326
+ *         int_t a = a1.shape[0], b = a2.shape[0]
+ *         int_t i0 = max(k - b // 2, 0), i1 = min(k - b//2 + b, a), i
+ *         float_t x = 0             # <<<<<<<<<<<<<<
+ *     for i in range(i0, i1):
+ *         x += a1[i] * a2[k + b//2 - i]
  */
-    __pyx_t_2 = __pyx_v_k;
-    __pyx_v_x = (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_2 * __pyx_v_array.strides[0]) )));
+  __pyx_v_x = 0.0;
 
-    /* "beam_calc.pyx":351
- *     while l < m:
- *         x = array[k]
- *         i = l; j = m             # <<<<<<<<<<<<<<
- *         while 1:
- *             while array[i] < x: i += 1
+  /* "beam_calc.pyx":327
+ *         int_t i0 = max(k - b // 2, 0), i1 = min(k - b//2 + b, a), i
+ *         float_t x = 0
+ *     for i in range(i0, i1):             # <<<<<<<<<<<<<<
+ *         x += a1[i] * a2[k + b//2 - i]
+ *     return x
  */
-    __pyx_v_i = __pyx_v_l;
-    __pyx_v_j = __pyx_v_m;
+  __pyx_t_4 = __pyx_v_i1;
+  __pyx_t_3 = __pyx_t_4;
+  for (__pyx_t_2 = __pyx_v_i0; __pyx_t_2 < __pyx_t_3; __pyx_t_2+=1) {
+    __pyx_v_i = __pyx_t_2;
 
-    /* "beam_calc.pyx":352
- *         x = array[k]
- *         i = l; j = m
- *         while 1:             # <<<<<<<<<<<<<<
- *             while array[i] < x: i += 1
- *             while x < array[j]: j -= 1
+    /* "beam_calc.pyx":328
+ *         float_t x = 0
+ *     for i in range(i0, i1):
+ *         x += a1[i] * a2[k + b//2 - i]             # <<<<<<<<<<<<<<
+ *     return x
+ * 
  */
-    while (1) {
+    __pyx_t_5 = __pyx_v_i;
+    __pyx_t_6 = ((__pyx_v_k + (__pyx_v_b / 2)) - __pyx_v_i);
+    __pyx_v_x = (__pyx_v_x + ((*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_a1.data) + __pyx_t_5)) ))) * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_a2.data) + __pyx_t_6)) )))));
+  }
 
-      /* "beam_calc.pyx":353
- *         i = l; j = m
- *         while 1:
- *             while array[i] < x: i += 1             # <<<<<<<<<<<<<<
- *             while x < array[j]: j -= 1
- *             if i <= j:
+  /* "beam_calc.pyx":329
+ *     for i in range(i0, i1):
+ *         x += a1[i] * a2[k + b//2 - i]
+ *     return x             # <<<<<<<<<<<<<<
+ * 
+ * cdef void make_frame_c(uint_t[:, ::1] frame, float_t[::1] i_x, float_t[::1] i_y,
  */
-      while (1) {
-        __pyx_t_3 = __pyx_v_i;
-        __pyx_t_1 = (((*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_3 * __pyx_v_array.strides[0]) ))) < __pyx_v_x) != 0);
-        if (!__pyx_t_1) break;
-        __pyx_v_i = (__pyx_v_i + 1);
-      }
+  __pyx_r = __pyx_v_x;
+  goto __pyx_L0;
 
-      /* "beam_calc.pyx":354
- *         while 1:
- *             while array[i] < x: i += 1
- *             while x < array[j]: j -= 1             # <<<<<<<<<<<<<<
- *             if i <= j:
- *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
+  /* "beam_calc.pyx":322
+ *     return np.asarray(br_tr)
+ * 
+ * cdef float_t convolve_c(float_t[::1] a1, float_t[::1] a2, int_t k) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t a = a1.shape[0], b = a2.shape[0]
  */
-      while (1) {
-        __pyx_t_4 = __pyx_v_j;
-        __pyx_t_1 = ((__pyx_v_x < (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_4 * __pyx_v_array.strides[0]) )))) != 0);
-        if (!__pyx_t_1) break;
-        __pyx_v_j = (__pyx_v_j - 1);
-      }
 
-      /* "beam_calc.pyx":355
- *             while array[i] < x: i += 1
- *             while x < array[j]: j -= 1
- *             if i <= j:             # <<<<<<<<<<<<<<
- *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
- *                 i += 1; j -= 1
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "beam_calc.pyx":331
+ *     return x
+ * 
+ * cdef void make_frame_c(uint_t[:, ::1] frame, float_t[::1] i_x, float_t[::1] i_y,             # <<<<<<<<<<<<<<
+ *                        float_t[::1] sc, float_t pix_size, unsigned long seed) nogil:
+ *     cdef:
  */
-      __pyx_t_1 = ((__pyx_v_i <= __pyx_v_j) != 0);
-      if (__pyx_t_1) {
 
-        /* "beam_calc.pyx":356
- *             while x < array[j]: j -= 1
- *             if i <= j:
- *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp             # <<<<<<<<<<<<<<
- *                 i += 1; j -= 1
- *             if i > j: break
+static void __pyx_f_9beam_calc_make_frame_c(__Pyx_memviewslice __pyx_v_frame, __Pyx_memviewslice __pyx_v_i_x, __Pyx_memviewslice __pyx_v_i_y, __Pyx_memviewslice __pyx_v_sc, __pyx_t_9beam_calc_float_t __pyx_v_pix_size, unsigned long __pyx_v_seed) {
+  __pyx_t_9beam_calc_int_t __pyx_v_b;
+  __pyx_t_9beam_calc_int_t __pyx_v_c;
+  __pyx_t_9beam_calc_int_t __pyx_v_j;
+  __pyx_t_9beam_calc_int_t __pyx_v_k;
+  gsl_rng *__pyx_v_r;
+  __pyx_t_9beam_calc_float_t __pyx_v_i_xs;
+  __pyx_t_9beam_calc_int_t __pyx_t_1;
+  __pyx_t_9beam_calc_int_t __pyx_t_2;
+  __pyx_t_9beam_calc_int_t __pyx_t_3;
+  __pyx_t_9beam_calc_int_t __pyx_t_4;
+  __pyx_t_9beam_calc_int_t __pyx_t_5;
+  __pyx_t_9beam_calc_int_t __pyx_t_6;
+  __pyx_t_9beam_calc_int_t __pyx_t_7;
+  __pyx_t_9beam_calc_int_t __pyx_t_8;
+  __pyx_t_9beam_calc_int_t __pyx_t_9;
+
+  /* "beam_calc.pyx":334
+ *                        float_t[::1] sc, float_t pix_size, unsigned long seed) nogil:
+ *     cdef:
+ *         int_t b = i_y.shape[0], c = i_x.shape[0], j, k             # <<<<<<<<<<<<<<
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
+ *         float_t i_xs
+ */
+  __pyx_v_b = (__pyx_v_i_y.shape[0]);
+  __pyx_v_c = (__pyx_v_i_x.shape[0]);
+
+  /* "beam_calc.pyx":335
+ *     cdef:
+ *         int_t b = i_y.shape[0], c = i_x.shape[0], j, k
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)             # <<<<<<<<<<<<<<
+ *         float_t i_xs
+ *     gsl_rng_set(r, seed)
  */
-        __pyx_t_5 = __pyx_v_i;
-        __pyx_v_tmp = (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_5 * __pyx_v_array.strides[0]) )));
-        __pyx_t_6 = __pyx_v_j;
-        __pyx_t_7 = __pyx_v_i;
-        *((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_7 * __pyx_v_array.strides[0]) )) = (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_6 * __pyx_v_array.strides[0]) )));
-        __pyx_t_8 = __pyx_v_j;
-        *((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_8 * __pyx_v_array.strides[0]) )) = __pyx_v_tmp;
+  __pyx_v_r = gsl_rng_alloc(gsl_rng_mt19937);
 
-        /* "beam_calc.pyx":357
- *             if i <= j:
- *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
- *                 i += 1; j -= 1             # <<<<<<<<<<<<<<
- *             if i > j: break
- *         if j < k: l = i
+  /* "beam_calc.pyx":337
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
+ *         float_t i_xs
+ *     gsl_rng_set(r, seed)             # <<<<<<<<<<<<<<
+ *     for k in range(c):
+ *         i_xs = convolve_c(i_x, sc, k)
  */
-        __pyx_v_i = (__pyx_v_i + 1);
-        __pyx_v_j = (__pyx_v_j - 1);
+  gsl_rng_set(__pyx_v_r, __pyx_v_seed);
 
-        /* "beam_calc.pyx":355
- *             while array[i] < x: i += 1
- *             while x < array[j]: j -= 1
- *             if i <= j:             # <<<<<<<<<<<<<<
- *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
- *                 i += 1; j -= 1
+  /* "beam_calc.pyx":338
+ *         float_t i_xs
+ *     gsl_rng_set(r, seed)
+ *     for k in range(c):             # <<<<<<<<<<<<<<
+ *         i_xs = convolve_c(i_x, sc, k)
+ *         for j in range(b):
  */
-      }
+  __pyx_t_1 = __pyx_v_c;
+  __pyx_t_2 = __pyx_t_1;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_k = __pyx_t_3;
 
-      /* "beam_calc.pyx":358
- *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
- *                 i += 1; j -= 1
- *             if i > j: break             # <<<<<<<<<<<<<<
- *         if j < k: l = i
- *         if k < i: m = j
+    /* "beam_calc.pyx":339
+ *     gsl_rng_set(r, seed)
+ *     for k in range(c):
+ *         i_xs = convolve_c(i_x, sc, k)             # <<<<<<<<<<<<<<
+ *         for j in range(b):
+ *             frame[j, k] = gsl_ran_poisson(r, i_xs * i_y[j] * pix_size**2)
  */
-      __pyx_t_1 = ((__pyx_v_i > __pyx_v_j) != 0);
-      if (__pyx_t_1) {
-        goto __pyx_L6_break;
-      }
-    }
-    __pyx_L6_break:;
+    __pyx_v_i_xs = __pyx_f_9beam_calc_convolve_c(__pyx_v_i_x, __pyx_v_sc, __pyx_v_k);
 
-    /* "beam_calc.pyx":359
- *                 i += 1; j -= 1
- *             if i > j: break
- *         if j < k: l = i             # <<<<<<<<<<<<<<
- *         if k < i: m = j
- *     return array[k]
+    /* "beam_calc.pyx":340
+ *     for k in range(c):
+ *         i_xs = convolve_c(i_x, sc, k)
+ *         for j in range(b):             # <<<<<<<<<<<<<<
+ *             frame[j, k] = gsl_ran_poisson(r, i_xs * i_y[j] * pix_size**2)
+ *     gsl_rng_free(r)
  */
-    __pyx_t_1 = ((__pyx_v_j < __pyx_v_k) != 0);
-    if (__pyx_t_1) {
-      __pyx_v_l = __pyx_v_i;
-    }
+    __pyx_t_4 = __pyx_v_b;
+    __pyx_t_5 = __pyx_t_4;
+    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+      __pyx_v_j = __pyx_t_6;
 
-    /* "beam_calc.pyx":360
- *             if i > j: break
- *         if j < k: l = i
- *         if k < i: m = j             # <<<<<<<<<<<<<<
- *     return array[k]
+      /* "beam_calc.pyx":341
+ *         i_xs = convolve_c(i_x, sc, k)
+ *         for j in range(b):
+ *             frame[j, k] = gsl_ran_poisson(r, i_xs * i_y[j] * pix_size**2)             # <<<<<<<<<<<<<<
+ *     gsl_rng_free(r)
  * 
  */
-    __pyx_t_1 = ((__pyx_v_k < __pyx_v_i) != 0);
-    if (__pyx_t_1) {
-      __pyx_v_m = __pyx_v_j;
+      __pyx_t_7 = __pyx_v_j;
+      __pyx_t_8 = __pyx_v_j;
+      __pyx_t_9 = __pyx_v_k;
+      *((__pyx_t_9beam_calc_uint_t *) ( /* dim=1 */ ((char *) (((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_frame.data + __pyx_t_8 * __pyx_v_frame.strides[0]) )) + __pyx_t_9)) )) = gsl_ran_poisson(__pyx_v_r, ((__pyx_v_i_xs * (*((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_i_y.data) + __pyx_t_7)) )))) * pow(__pyx_v_pix_size, 2.0)));
     }
   }
 
-  /* "beam_calc.pyx":361
- *         if j < k: l = i
- *         if k < i: m = j
- *     return array[k]             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":342
+ *         for j in range(b):
+ *             frame[j, k] = gsl_ran_poisson(r, i_xs * i_y[j] * pix_size**2)
+ *     gsl_rng_free(r)             # <<<<<<<<<<<<<<
  * 
- * def make_whitefield(uint_t[:, :, ::1] data, uint8_t[:, ::1] mask):
+ * def make_frames(float_t[:, ::1] i_x, float_t[::1] i_y, float_t[::1] sc_x, float_t[::1] sc_y, float_t pix_size):
  */
-  __pyx_t_9 = __pyx_v_k;
-  __pyx_r = (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_9 * __pyx_v_array.strides[0]) )));
-  goto __pyx_L0;
+  gsl_rng_free(__pyx_v_r);
 
-  /* "beam_calc.pyx":345
- *     return np.asarray(frames)
+  /* "beam_calc.pyx":331
+ *     return x
  * 
- * cdef uint_t wirthselect_uint(uint_t[:] array, int k) nogil:             # <<<<<<<<<<<<<<
+ * cdef void make_frame_c(uint_t[:, ::1] frame, float_t[::1] i_x, float_t[::1] i_y,             # <<<<<<<<<<<<<<
+ *                        float_t[::1] sc, float_t pix_size, unsigned long seed) nogil:
  *     cdef:
- *         int_t l = 0, m = array.shape[0] - 1, i, j
  */
 
   /* function exit code */
-  __pyx_L0:;
-  return __pyx_r;
 }
 
-/* "beam_calc.pyx":363
- *     return array[k]
+/* "beam_calc.pyx":344
+ *     gsl_rng_free(r)
  * 
- * def make_whitefield(uint_t[:, :, ::1] data, uint8_t[:, ::1] mask):             # <<<<<<<<<<<<<<
+ * def make_frames(float_t[:, ::1] i_x, float_t[::1] i_y, float_t[::1] sc_x, float_t[::1] sc_y, float_t pix_size):             # <<<<<<<<<<<<<<
  *     """
- *     Return whitefield based on median filtering of the stack of frames
+ *     Generate intensity frames with Poisson noise from x and y coordinate wavefront profiles
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_9beam_calc_19make_whitefield(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_9beam_calc_18make_whitefield[] = "\n    Return whitefield based on median filtering of the stack of frames\n\n    data - stack of frames\n    mask - bad pixel mask\n    ";
-static PyMethodDef __pyx_mdef_9beam_calc_19make_whitefield = {"make_whitefield", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_19make_whitefield, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_18make_whitefield};
-static PyObject *__pyx_pw_9beam_calc_19make_whitefield(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  __Pyx_memviewslice __pyx_v_data = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_mask = { 0, 0, { 0 }, { 0 }, { 0 } };
+static PyObject *__pyx_pw_9beam_calc_19make_frames(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_18make_frames[] = "\n    Generate intensity frames with Poisson noise from x and y coordinate wavefront profiles\n\n    i_x, i_y - x and y coordinate intensity profiles\n    sc_x, sc_y - source rocking curve along x- and y-axes\n    pix_size - pixel size [um]\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_19make_frames = {"make_frames", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_19make_frames, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_18make_frames};
+static PyObject *__pyx_pw_9beam_calc_19make_frames(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __Pyx_memviewslice __pyx_v_i_x = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_i_y = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_sc_x = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_sc_y = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_float_t __pyx_v_pix_size;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("make_whitefield (wrapper)", 0);
+  __Pyx_RefNannySetupContext("make_frames (wrapper)", 0);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_mask,0};
-    PyObject* values[2] = {0,0};
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i_x,&__pyx_n_s_i_y,&__pyx_n_s_sc_x,&__pyx_n_s_sc_y,&__pyx_n_s_pix_size,0};
+    PyObject* values[5] = {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  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);
@@ -8384,52 +7704,75 @@ static PyObject *__pyx_pw_9beam_calc_19make_whitefield(PyObject *__pyx_self, PyO
       kw_args = PyDict_Size(__pyx_kwds);
       switch (pos_args) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i_x)) != 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_mask)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, 1); __PYX_ERR(0, 344, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sc_x)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, 2); __PYX_ERR(0, 344, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sc_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, 3); __PYX_ERR(0, 344, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pix_size)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_whitefield", 1, 2, 2, 1); __PYX_ERR(0, 363, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, 4); __PYX_ERR(0, 344, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_whitefield") < 0)) __PYX_ERR(0, 363, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_frames") < 0)) __PYX_ERR(0, 344, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
       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);
     }
-    __pyx_v_data = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_9beam_calc_uint_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_data.memview)) __PYX_ERR(0, 363, __pyx_L3_error)
-    __pyx_v_mask = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_uint8_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_mask.memview)) __PYX_ERR(0, 363, __pyx_L3_error)
+    __pyx_v_i_x = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_i_x.memview)) __PYX_ERR(0, 344, __pyx_L3_error)
+    __pyx_v_i_y = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_i_y.memview)) __PYX_ERR(0, 344, __pyx_L3_error)
+    __pyx_v_sc_x = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_sc_x.memview)) __PYX_ERR(0, 344, __pyx_L3_error)
+    __pyx_v_sc_y = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_sc_y.memview)) __PYX_ERR(0, 344, __pyx_L3_error)
+    __pyx_v_pix_size = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_pix_size == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 344, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("make_whitefield", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 363, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("make_frames", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 344, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("beam_calc.make_whitefield", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("beam_calc.make_frames", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_9beam_calc_18make_whitefield(__pyx_self, __pyx_v_data, __pyx_v_mask);
+  __pyx_r = __pyx_pf_9beam_calc_18make_frames(__pyx_self, __pyx_v_i_x, __pyx_v_i_y, __pyx_v_sc_x, __pyx_v_sc_y, __pyx_v_pix_size);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_9beam_calc_18make_whitefield(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_data, __Pyx_memviewslice __pyx_v_mask) {
+static PyObject *__pyx_pf_9beam_calc_18make_frames(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_i_x, __Pyx_memviewslice __pyx_v_i_y, __Pyx_memviewslice __pyx_v_sc_x, __Pyx_memviewslice __pyx_v_sc_y, __pyx_t_9beam_calc_float_t __pyx_v_pix_size) {
   __pyx_t_9beam_calc_int_t __pyx_v_a;
   __pyx_t_9beam_calc_int_t __pyx_v_b;
   __pyx_t_9beam_calc_int_t __pyx_v_c;
   __pyx_t_9beam_calc_int_t __pyx_v_i;
-  __pyx_t_9beam_calc_int_t __pyx_v_j;
-  __pyx_t_9beam_calc_int_t __pyx_v_k;
-  __pyx_t_9beam_calc_int_t __pyx_v_max_threads;
-  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_array = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_frames = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_i_ys = { 0, 0, { 0 }, { 0 }, { 0 } };
+  gsl_rng *__pyx_v_r;
+  unsigned long __pyx_v_seed;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
@@ -8438,148 +7781,159 @@ static PyObject *__pyx_pf_9beam_calc_18make_whitefield(CYTHON_UNUSED PyObject *_
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
   __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_int_t __pyx_t_7;
+  __Pyx_memviewslice __pyx_t_7 = { 0, 0, { 0 }, { 0 }, { 0 } };
   __pyx_t_9beam_calc_int_t __pyx_t_8;
   __pyx_t_9beam_calc_int_t __pyx_t_9;
   __pyx_t_9beam_calc_int_t __pyx_t_10;
   __pyx_t_9beam_calc_int_t __pyx_t_11;
-  __pyx_t_9beam_calc_int_t __pyx_t_12;
-  __pyx_t_9beam_calc_int_t __pyx_t_13;
-  __pyx_t_9beam_calc_int_t __pyx_t_14;
-  int __pyx_t_15;
-  __Pyx_memviewslice __pyx_t_16 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_t_17 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_t_18 = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __pyx_t_9beam_calc_int_t __pyx_t_19;
-  __pyx_t_9beam_calc_int_t __pyx_t_20;
-  __pyx_t_9beam_calc_int_t __pyx_t_21;
-  __pyx_t_9beam_calc_int_t __pyx_t_22;
-  __Pyx_RefNannySetupContext("make_whitefield", 0);
+  __Pyx_memviewslice __pyx_t_12 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("make_frames", 0);
 
-  /* "beam_calc.pyx":371
+  /* "beam_calc.pyx":353
  *     """
  *     cdef:
- *         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k             # <<<<<<<<<<<<<<
- *         int_t max_threads = openmp.omp_get_max_threads()
- *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
+ *         int_t a = i_x.shape[0], b = i_y.shape[0], c = i_x.shape[1], i             # <<<<<<<<<<<<<<
+ *         uint_t[:, :, ::1] frames = np.empty((a, b, c), dtype=np.uint64)
+ *         float_t[::1] i_ys = np.empty(b, dtype=np.float64)
  */
-  __pyx_v_a = (__pyx_v_data.shape[0]);
-  __pyx_v_b = (__pyx_v_data.shape[1]);
-  __pyx_v_c = (__pyx_v_data.shape[2]);
+  __pyx_v_a = (__pyx_v_i_x.shape[0]);
+  __pyx_v_b = (__pyx_v_i_y.shape[0]);
+  __pyx_v_c = (__pyx_v_i_x.shape[1]);
 
-  /* "beam_calc.pyx":372
+  /* "beam_calc.pyx":354
  *     cdef:
- *         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k
- *         int_t max_threads = openmp.omp_get_max_threads()             # <<<<<<<<<<<<<<
- *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
- *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
- */
-  __pyx_v_max_threads = omp_get_max_threads();
-
-  /* "beam_calc.pyx":373
- *         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k
- *         int_t max_threads = openmp.omp_get_max_threads()
- *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)             # <<<<<<<<<<<<<<
- *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
- *     for j in prange(b, schedule='guided', nogil=True):
+ *         int_t a = i_x.shape[0], b = i_y.shape[0], c = i_x.shape[1], i
+ *         uint_t[:, :, ::1] frames = np.empty((a, b, c), dtype=np.uint64)             # <<<<<<<<<<<<<<
+ *         float_t[::1] i_ys = np.empty(b, dtype=np.float64)
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 373, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 373, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 354, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 373, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_c); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 373, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 354, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 373, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyInt_From_npy_int64(__pyx_v_c); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 354, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 354, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
   __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
   __pyx_t_1 = 0;
   __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 373, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
   __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 373, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 354, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 373, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_uint64); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 373, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 354, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 354, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_uint64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 354, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 373, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 373, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_uint_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 373, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_wf = __pyx_t_6;
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_9beam_calc_uint_t(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 354, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_frames = __pyx_t_6;
   __pyx_t_6.memview = NULL;
   __pyx_t_6.data = NULL;
 
-  /* "beam_calc.pyx":374
- *         int_t max_threads = openmp.omp_get_max_threads()
- *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
- *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)             # <<<<<<<<<<<<<<
- *     for j in prange(b, schedule='guided', nogil=True):
- *         i = openmp.omp_get_thread_num()
+  /* "beam_calc.pyx":355
+ *         int_t a = i_x.shape[0], b = i_y.shape[0], c = i_x.shape[1], i
+ *         uint_t[:, :, ::1] frames = np.empty((a, b, c), dtype=np.uint64)
+ *         float_t[::1] i_ys = np.empty(b, dtype=np.float64)             # <<<<<<<<<<<<<<
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
+ *         unsigned long seed
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 374, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 355, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 374, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 355, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyInt_From_npy_int64(__pyx_v_max_threads); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 374, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 374, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 374, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 355, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_5);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
-  __pyx_t_5 = 0;
-  __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 374, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float64); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 355, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 355, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 374, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 374, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_uint64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 374, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_uint_t(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 374, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_array = __pyx_t_6;
-  __pyx_t_6.memview = NULL;
-  __pyx_t_6.data = NULL;
+  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(__pyx_t_3, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 355, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_i_ys = __pyx_t_7;
+  __pyx_t_7.memview = NULL;
+  __pyx_t_7.data = NULL;
+
+  /* "beam_calc.pyx":356
+ *         uint_t[:, :, ::1] frames = np.empty((a, b, c), dtype=np.uint64)
+ *         float_t[::1] i_ys = np.empty(b, dtype=np.float64)
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)             # <<<<<<<<<<<<<<
+ *         unsigned long seed
+ *     for i in range(b):
+ */
+  __pyx_v_r = gsl_rng_alloc(gsl_rng_mt19937);
+
+  /* "beam_calc.pyx":358
+ *         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
+ *         unsigned long seed
+ *     for i in range(b):             # <<<<<<<<<<<<<<
+ *         i_ys[i] = convolve_c(i_y, sc_y, i)
+ *     for i in prange(a, schedule='guided', nogil=True):
+ */
+  __pyx_t_8 = __pyx_v_b;
+  __pyx_t_9 = __pyx_t_8;
+  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
+    __pyx_v_i = __pyx_t_10;
 
-  /* "beam_calc.pyx":375
- *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
- *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
- *     for j in prange(b, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         i = openmp.omp_get_thread_num()
- *         for k in range(c):
+    /* "beam_calc.pyx":359
+ *         unsigned long seed
+ *     for i in range(b):
+ *         i_ys[i] = convolve_c(i_y, sc_y, i)             # <<<<<<<<<<<<<<
+ *     for i in prange(a, schedule='guided', nogil=True):
+ *         seed = gsl_rng_get(r)
+ */
+    __pyx_t_11 = __pyx_v_i;
+    *((__pyx_t_9beam_calc_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_9beam_calc_float_t *) __pyx_v_i_ys.data) + __pyx_t_11)) )) = __pyx_f_9beam_calc_convolve_c(__pyx_v_i_y, __pyx_v_sc_y, __pyx_v_i);
+  }
+
+  /* "beam_calc.pyx":360
+ *     for i in range(b):
+ *         i_ys[i] = convolve_c(i_y, sc_y, i)
+ *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         seed = gsl_rng_get(r)
+ *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
  */
   {
       #ifdef WITH_THREAD
@@ -8588,258 +7942,87 @@ static PyObject *__pyx_pf_9beam_calc_18make_whitefield(CYTHON_UNUSED PyObject *_
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
-        __pyx_t_7 = __pyx_v_b;
+        __pyx_t_8 = __pyx_v_a;
         if ((1 == 0)) abort();
         {
-            __pyx_t_9beam_calc_int_t __pyx_parallel_temp0 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
-            __pyx_t_9beam_calc_int_t __pyx_parallel_temp1 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
-            __pyx_t_9beam_calc_int_t __pyx_parallel_temp2 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
-            const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0;
-            PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL;
-            int __pyx_parallel_why;
-            __pyx_parallel_why = 0;
             #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
                 #undef likely
                 #undef unlikely
                 #define likely(x)   (x)
                 #define unlikely(x) (x)
             #endif
-            __pyx_t_9 = (__pyx_t_7 - 0 + 1 - 1/abs(1)) / 1;
-            if (__pyx_t_9 > 0)
+            __pyx_t_10 = (__pyx_t_8 - 0 + 1 - 1/abs(1)) / 1;
+            if (__pyx_t_10 > 0)
             {
                 #ifdef _OPENMP
-                #pragma omp parallel private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22) firstprivate(__pyx_t_16, __pyx_t_17, __pyx_t_18) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb)
+                #pragma omp parallel firstprivate(__pyx_t_12, __pyx_t_7)
                 #endif /* _OPENMP */
                 {
                     #ifdef _OPENMP
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    Py_BEGIN_ALLOW_THREADS
-                    #endif /* _OPENMP */
-                    #ifdef _OPENMP
-                    #pragma omp for lastprivate(__pyx_v_i) firstprivate(__pyx_v_j) lastprivate(__pyx_v_j) lastprivate(__pyx_v_k) schedule(guided)
+                    #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) lastprivate(__pyx_v_seed) schedule(guided)
                     #endif /* _OPENMP */
-                    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
-                        if (__pyx_parallel_why < 2)
+                    for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_10; __pyx_t_9++){
                         {
-                            __pyx_v_j = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
+                            __pyx_v_i = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_9);
                             /* Initialize private variables to invalid values */
-                            __pyx_v_i = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
-                            __pyx_v_k = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
-
-                            /* "beam_calc.pyx":376
- *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
- *     for j in prange(b, schedule='guided', nogil=True):
- *         i = openmp.omp_get_thread_num()             # <<<<<<<<<<<<<<
- *         for k in range(c):
- *             if mask[j, k]:
- */
-                            __pyx_v_i = omp_get_thread_num();
-
-                            /* "beam_calc.pyx":377
- *     for j in prange(b, schedule='guided', nogil=True):
- *         i = openmp.omp_get_thread_num()
- *         for k in range(c):             # <<<<<<<<<<<<<<
- *             if mask[j, k]:
- *                 array[i] = data[:, j, k]
- */
-                            __pyx_t_10 = __pyx_v_c;
-                            __pyx_t_11 = __pyx_t_10;
-                            for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
-                              __pyx_v_k = __pyx_t_12;
+                            __pyx_v_seed = ((unsigned long)0xbad0bad0);
 
-                              /* "beam_calc.pyx":378
- *         i = openmp.omp_get_thread_num()
- *         for k in range(c):
- *             if mask[j, k]:             # <<<<<<<<<<<<<<
- *                 array[i] = data[:, j, k]
- *                 wf[j, k] = wirthselect_uint(array[i], a // 2)
+                            /* "beam_calc.pyx":361
+ *         i_ys[i] = convolve_c(i_y, sc_y, i)
+ *     for i in prange(a, schedule='guided', nogil=True):
+ *         seed = gsl_rng_get(r)             # <<<<<<<<<<<<<<
+ *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
+ *     gsl_rng_free(r)
  */
-                              __pyx_t_13 = __pyx_v_j;
-                              __pyx_t_14 = __pyx_v_k;
-                              __pyx_t_15 = ((*((__pyx_t_9beam_calc_uint8_t *) ( /* dim=1 */ ((char *) (((__pyx_t_9beam_calc_uint8_t *) ( /* dim=0 */ (__pyx_v_mask.data + __pyx_t_13 * __pyx_v_mask.strides[0]) )) + __pyx_t_14)) ))) != 0);
-                              if (__pyx_t_15) {
+                            __pyx_v_seed = gsl_rng_get(__pyx_v_r);
 
-                                /* "beam_calc.pyx":379
- *         for k in range(c):
- *             if mask[j, k]:
- *                 array[i] = data[:, j, k]             # <<<<<<<<<<<<<<
- *                 wf[j, k] = wirthselect_uint(array[i], a // 2)
- *             else:
+                            /* "beam_calc.pyx":362
+ *     for i in prange(a, schedule='guided', nogil=True):
+ *         seed = gsl_rng_get(r)
+ *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)             # <<<<<<<<<<<<<<
+ *     gsl_rng_free(r)
+ *     return np.asarray(frames)
  */
-                                __pyx_t_16.data = __pyx_v_data.data;
-                                __pyx_t_16.memview = __pyx_v_data.memview;
-                                __PYX_INC_MEMVIEW(&__pyx_t_16, 0);
-                                __pyx_t_16.shape[0] = __pyx_v_data.shape[0];
-__pyx_t_16.strides[0] = __pyx_v_data.strides[0];
-    __pyx_t_16.suboffsets[0] = -1;
-
-{
-    Py_ssize_t __pyx_tmp_idx = __pyx_v_j;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_data.strides[1];
-        if ((0)) __PYX_ERR(0, 379, __pyx_L8_error)
-        __pyx_t_16.data += __pyx_tmp_idx * __pyx_tmp_stride;
-}
-
-{
-    Py_ssize_t __pyx_tmp_idx = __pyx_v_k;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_data.strides[2];
-        if ((0)) __PYX_ERR(0, 379, __pyx_L8_error)
-        __pyx_t_16.data += __pyx_tmp_idx * __pyx_tmp_stride;
-}
-
-__pyx_t_17.data = __pyx_v_array.data;
-                                __pyx_t_17.memview = __pyx_v_array.memview;
-                                __PYX_INC_MEMVIEW(&__pyx_t_17, 0);
-                                {
+                            __pyx_t_12.data = __pyx_v_frames.data;
+                            __pyx_t_12.memview = __pyx_v_frames.memview;
+                            __PYX_INC_MEMVIEW(&__pyx_t_12, 0);
+                            {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_array.strides[0];
-        if ((0)) __PYX_ERR(0, 379, __pyx_L8_error)
-        __pyx_t_17.data += __pyx_tmp_idx * __pyx_tmp_stride;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_frames.strides[0];
+        __pyx_t_12.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
-__pyx_t_17.shape[0] = __pyx_v_array.shape[1];
-__pyx_t_17.strides[0] = __pyx_v_array.strides[1];
-    __pyx_t_17.suboffsets[0] = -1;
+__pyx_t_12.shape[0] = __pyx_v_frames.shape[1];
+__pyx_t_12.strides[0] = __pyx_v_frames.strides[1];
+    __pyx_t_12.suboffsets[0] = -1;
 
-if (unlikely(__pyx_memoryview_copy_contents(__pyx_t_16, __pyx_t_17, 1, 1, 0) < 0)) __PYX_ERR(0, 379, __pyx_L8_error)
-                                __PYX_XDEC_MEMVIEW(&__pyx_t_17, 0);
-                                __pyx_t_17.memview = NULL;
-                                __pyx_t_17.data = NULL;
-                                __PYX_XDEC_MEMVIEW(&__pyx_t_16, 0);
-                                __pyx_t_16.memview = NULL;
-                                __pyx_t_16.data = NULL;
+__pyx_t_12.shape[1] = __pyx_v_frames.shape[2];
+__pyx_t_12.strides[1] = __pyx_v_frames.strides[2];
+    __pyx_t_12.suboffsets[1] = -1;
 
-                                /* "beam_calc.pyx":380
- *             if mask[j, k]:
- *                 array[i] = data[:, j, k]
- *                 wf[j, k] = wirthselect_uint(array[i], a // 2)             # <<<<<<<<<<<<<<
- *             else:
- *                 wf[j, k] = 0
- */
-                                __pyx_t_18.data = __pyx_v_array.data;
-                                __pyx_t_18.memview = __pyx_v_array.memview;
-                                __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
-                                {
+__pyx_t_7.data = __pyx_v_i_x.data;
+                            __pyx_t_7.memview = __pyx_v_i_x.memview;
+                            __PYX_INC_MEMVIEW(&__pyx_t_7, 0);
+                            {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
-    Py_ssize_t __pyx_tmp_stride = __pyx_v_array.strides[0];
-        if ((0)) __PYX_ERR(0, 380, __pyx_L8_error)
-        __pyx_t_18.data += __pyx_tmp_idx * __pyx_tmp_stride;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_i_x.strides[0];
+        __pyx_t_7.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
-__pyx_t_18.shape[0] = __pyx_v_array.shape[1];
-__pyx_t_18.strides[0] = __pyx_v_array.strides[1];
-    __pyx_t_18.suboffsets[0] = -1;
-
-__pyx_t_19 = __pyx_v_j;
-                                __pyx_t_20 = __pyx_v_k;
-                                *((__pyx_t_9beam_calc_uint_t *) ( /* dim=1 */ ((char *) (((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_wf.data + __pyx_t_19 * __pyx_v_wf.strides[0]) )) + __pyx_t_20)) )) = __pyx_f_9beam_calc_wirthselect_uint(__pyx_t_18, (__pyx_v_a / 2));
-                                __PYX_XDEC_MEMVIEW(&__pyx_t_18, 0);
-                                __pyx_t_18.memview = NULL;
-                                __pyx_t_18.data = NULL;
-
-                                /* "beam_calc.pyx":378
- *         i = openmp.omp_get_thread_num()
- *         for k in range(c):
- *             if mask[j, k]:             # <<<<<<<<<<<<<<
- *                 array[i] = data[:, j, k]
- *                 wf[j, k] = wirthselect_uint(array[i], a // 2)
- */
-                                goto __pyx_L12;
-                              }
-
-                              /* "beam_calc.pyx":382
- *                 wf[j, k] = wirthselect_uint(array[i], a // 2)
- *             else:
- *                 wf[j, k] = 0             # <<<<<<<<<<<<<<
- *     return np.asarray(wf)
- */
-                              /*else*/ {
-                                __pyx_t_21 = __pyx_v_j;
-                                __pyx_t_22 = __pyx_v_k;
-                                *((__pyx_t_9beam_calc_uint_t *) ( /* dim=1 */ ((char *) (((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_wf.data + __pyx_t_21 * __pyx_v_wf.strides[0]) )) + __pyx_t_22)) )) = 0;
-                              }
-                              __pyx_L12:;
-                            }
-                            goto __pyx_L14;
-                            __pyx_L8_error:;
-                            {
-                                #ifdef WITH_THREAD
-                                PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                                #endif
-                                #ifdef _OPENMP
-                                #pragma omp flush(__pyx_parallel_exc_type)
-                                #endif /* _OPENMP */
-                                if (!__pyx_parallel_exc_type) {
-                                  __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
-                                  __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
-                                  __Pyx_GOTREF(__pyx_parallel_exc_type);
-                                }
-                                #ifdef WITH_THREAD
-                                __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                                #endif
-                            }
-                            __pyx_parallel_why = 4;
-                            goto __pyx_L13;
-                            __pyx_L13:;
-                            #ifdef _OPENMP
-                            #pragma omp critical(__pyx_parallel_lastprivates4)
-                            #endif /* _OPENMP */
-                            {
-                                __pyx_parallel_temp0 = __pyx_v_i;
-                                __pyx_parallel_temp1 = __pyx_v_j;
-                                __pyx_parallel_temp2 = __pyx_v_k;
-                            }
-                            __pyx_L14:;
-                            #ifdef _OPENMP
-                            #pragma omp flush(__pyx_parallel_why)
-                            #endif /* _OPENMP */
-                        }
-                    }
-                    #ifdef _OPENMP
-                    Py_END_ALLOW_THREADS
-                    #else
-{
-#ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    #endif /* _OPENMP */
-                    /* Clean up any temporaries */
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_16, 0);
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_17, 0);
-                    __PYX_XDEC_MEMVIEW(&__pyx_t_18, 0);
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
-                    #ifndef _OPENMP
-}
-#endif /* _OPENMP */
-                }
-            }
-            if (__pyx_parallel_exc_type) {
-              /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
-              __pyx_parallel_why = 4;
-            }
-            if (__pyx_parallel_why) {
-              __pyx_v_i = __pyx_parallel_temp0;
-              __pyx_v_j = __pyx_parallel_temp1;
-              __pyx_v_k = __pyx_parallel_temp2;
-              switch (__pyx_parallel_why) {
-                    case 4:
-                {
-                    #ifdef WITH_THREAD
-                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-                    #endif
-                    __Pyx_GIVEREF(__pyx_parallel_exc_type);
-                    __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
-                    __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
-                    #ifdef WITH_THREAD
-                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                    #endif
+__pyx_t_7.shape[0] = __pyx_v_i_x.shape[1];
+__pyx_t_7.strides[0] = __pyx_v_i_x.strides[1];
+    __pyx_t_7.suboffsets[0] = -1;
+
+__pyx_f_9beam_calc_make_frame_c(__pyx_t_12, __pyx_t_7, __pyx_v_i_ys, __pyx_v_sc_x, __pyx_v_pix_size, __pyx_v_seed);
+                            __PYX_XDEC_MEMVIEW(&__pyx_t_12, 0);
+                            __pyx_t_12.memview = NULL;
+                            __pyx_t_12.data = NULL;
+                            __PYX_XDEC_MEMVIEW(&__pyx_t_7, 0);
+                            __pyx_t_7.memview = NULL;
+                            __pyx_t_7.data = NULL;
+                        }
+                    }
                 }
-                goto __pyx_L4_error;
-              }
             }
         }
         #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
@@ -8850,12 +8033,12 @@ __pyx_t_19 = __pyx_v_j;
         #endif
       }
 
-      /* "beam_calc.pyx":375
- *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
- *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
- *     for j in prange(b, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
- *         i = openmp.omp_get_thread_num()
- *         for k in range(c):
+      /* "beam_calc.pyx":360
+ *     for i in range(b):
+ *         i_ys[i] = convolve_c(i_y, sc_y, i)
+ *     for i in prange(a, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         seed = gsl_rng_get(r)
+ *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
  */
       /*finally:*/ {
         /*normal exit:*/{
@@ -8863,58 +8046,62 @@ __pyx_t_19 = __pyx_v_j;
           __Pyx_FastGIL_Forget();
           Py_BLOCK_THREADS
           #endif
-          goto __pyx_L5;
-        }
-        __pyx_L4_error: {
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L1_error;
+          goto __pyx_L7;
         }
-        __pyx_L5:;
+        __pyx_L7:;
       }
   }
 
-  /* "beam_calc.pyx":383
- *             else:
- *                 wf[j, k] = 0
- *     return np.asarray(wf)             # <<<<<<<<<<<<<<
+  /* "beam_calc.pyx":363
+ *         seed = gsl_rng_get(r)
+ *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
+ *     gsl_rng_free(r)             # <<<<<<<<<<<<<<
+ *     return np.asarray(frames)
+ * 
+ */
+  gsl_rng_free(__pyx_v_r);
+
+  /* "beam_calc.pyx":364
+ *         make_frame_c(frames[i], i_x[i], i_ys, sc_x, pix_size, seed)
+ *     gsl_rng_free(r)
+ *     return np.asarray(frames)             # <<<<<<<<<<<<<<
+ * 
+ * cdef uint_t wirthselect_uint(uint_t[:] array, int k) nogil:
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 383, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 383, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_wf, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_9beam_calc_uint_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_9beam_calc_uint_t, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 383, __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_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 364, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_asarray); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 364, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_frames, 3, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_9beam_calc_uint_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_9beam_calc_uint_t, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 364, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __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_3, function);
+      __Pyx_DECREF_SET(__pyx_t_4, 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, 383, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 364, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "beam_calc.pyx":363
- *     return array[k]
+  /* "beam_calc.pyx":344
+ *     gsl_rng_free(r)
  * 
- * def make_whitefield(uint_t[:, :, ::1] data, uint8_t[:, ::1] mask):             # <<<<<<<<<<<<<<
+ * def make_frames(float_t[:, ::1] i_x, float_t[::1] i_y, float_t[::1] sc_x, float_t[::1] sc_y, float_t pix_size):             # <<<<<<<<<<<<<<
  *     """
- *     Return whitefield based on median filtering of the stack of frames
+ *     Generate intensity frames with Poisson noise from x and y coordinate wavefront profiles
  */
 
   /* function exit code */
@@ -8925,878 +8112,815 @@ __pyx_t_19 = __pyx_v_j;
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
   __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_16, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
-  __Pyx_AddTraceback("beam_calc.make_whitefield", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_12, 1);
+  __Pyx_AddTraceback("beam_calc.make_frames", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_array, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_data, 1);
-  __PYX_XDEC_MEMVIEW(&__pyx_v_mask, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_frames, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_i_ys, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_i_x, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_i_y, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_sc_x, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_sc_y, 1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258
- *         # experimental exception made for __getbuffer__ and __releasebuffer__
- *         # -- the details of this may change.
- *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
- *             # This implementation of getbuffer is geared towards Cython
- *             # requirements, and does not yet fulfill the PEP.
+/* "beam_calc.pyx":366
+ *     return np.asarray(frames)
+ * 
+ * cdef uint_t wirthselect_uint(uint_t[:] array, int k) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t l = 0, m = array.shape[0] - 1, i, j
  */
 
-/* Python wrapper */
-static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
-static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
-  int __pyx_v_i;
-  int __pyx_v_ndim;
-  int __pyx_v_endian_detector;
-  int __pyx_v_little_endian;
-  int __pyx_v_t;
-  char *__pyx_v_f;
-  PyArray_Descr *__pyx_v_descr = 0;
-  int __pyx_v_offset;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
+static __pyx_t_9beam_calc_uint_t __pyx_f_9beam_calc_wirthselect_uint(__Pyx_memviewslice __pyx_v_array, int __pyx_v_k) {
+  __pyx_t_9beam_calc_int_t __pyx_v_l;
+  __pyx_t_9beam_calc_int_t __pyx_v_m;
+  __pyx_t_9beam_calc_int_t __pyx_v_i;
+  __pyx_t_9beam_calc_int_t __pyx_v_j;
+  __pyx_t_9beam_calc_uint_t __pyx_v_x;
+  __pyx_t_9beam_calc_uint_t __pyx_v_tmp;
+  __pyx_t_9beam_calc_uint_t __pyx_r;
   int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_t_4;
-  int __pyx_t_5;
-  int __pyx_t_6;
-  PyArray_Descr *__pyx_t_7;
-  PyObject *__pyx_t_8 = NULL;
-  char *__pyx_t_9;
-  if (__pyx_v_info == NULL) {
-    PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
-    return -1;
-  }
-  __Pyx_RefNannySetupContext("__getbuffer__", 0);
-  __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
-  __Pyx_GIVEREF(__pyx_v_info->obj);
+  Py_ssize_t __pyx_t_2;
+  __pyx_t_9beam_calc_int_t __pyx_t_3;
+  __pyx_t_9beam_calc_int_t __pyx_t_4;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265
- * 
- *             cdef int i, ndim
- *             cdef int endian_detector = 1             # <<<<<<<<<<<<<<
- *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
- * 
+  /* "beam_calc.pyx":368
+ * cdef uint_t wirthselect_uint(uint_t[:] array, int k) nogil:
+ *     cdef:
+ *         int_t l = 0, m = array.shape[0] - 1, i, j             # <<<<<<<<<<<<<<
+ *         uint_t x, tmp
+ *     while l < m:
  */
-  __pyx_v_endian_detector = 1;
+  __pyx_v_l = 0;
+  __pyx_v_m = ((__pyx_v_array.shape[0]) - 1);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266
- *             cdef int i, ndim
- *             cdef int endian_detector = 1
- *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
- * 
- *             ndim = PyArray_NDIM(self)
+  /* "beam_calc.pyx":370
+ *         int_t l = 0, m = array.shape[0] - 1, i, j
+ *         uint_t x, tmp
+ *     while l < m:             # <<<<<<<<<<<<<<
+ *         x = array[k]
+ *         i = l; j = m
  */
-  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+  while (1) {
+    __pyx_t_1 = ((__pyx_v_l < __pyx_v_m) != 0);
+    if (!__pyx_t_1) break;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268
- *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
- * 
- *             ndim = PyArray_NDIM(self)             # <<<<<<<<<<<<<<
- * 
- *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+    /* "beam_calc.pyx":371
+ *         uint_t x, tmp
+ *     while l < m:
+ *         x = array[k]             # <<<<<<<<<<<<<<
+ *         i = l; j = m
+ *         while 1:
  */
-  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);
+    __pyx_t_2 = __pyx_v_k;
+    __pyx_v_x = (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_2 * __pyx_v_array.strides[0]) )));
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270
- *             ndim = PyArray_NDIM(self)
- * 
- *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not C contiguous")
+    /* "beam_calc.pyx":372
+ *     while l < m:
+ *         x = array[k]
+ *         i = l; j = m             # <<<<<<<<<<<<<<
+ *         while 1:
+ *             while array[i] < x: i += 1
  */
-  __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
-  if (__pyx_t_2) {
-  } else {
-    __pyx_t_1 = __pyx_t_2;
-    goto __pyx_L4_bool_binop_done;
-  }
+    __pyx_v_i = __pyx_v_l;
+    __pyx_v_j = __pyx_v_m;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271
- * 
- *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):             # <<<<<<<<<<<<<<
- *                 raise ValueError(u"ndarray is not C contiguous")
- * 
+    /* "beam_calc.pyx":373
+ *         x = array[k]
+ *         i = l; j = m
+ *         while 1:             # <<<<<<<<<<<<<<
+ *             while array[i] < x: i += 1
+ *             while x < array[j]: j -= 1
  */
-  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0);
-  __pyx_t_1 = __pyx_t_2;
-  __pyx_L4_bool_binop_done:;
+    while (1) {
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270
- *             ndim = PyArray_NDIM(self)
- * 
- *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not C contiguous")
+      /* "beam_calc.pyx":374
+ *         i = l; j = m
+ *         while 1:
+ *             while array[i] < x: i += 1             # <<<<<<<<<<<<<<
+ *             while x < array[j]: j -= 1
+ *             if i <= j:
  */
-  if (unlikely(__pyx_t_1)) {
+      while (1) {
+        __pyx_t_3 = __pyx_v_i;
+        __pyx_t_1 = (((*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_3 * __pyx_v_array.strides[0]) ))) < __pyx_v_x) != 0);
+        if (!__pyx_t_1) break;
+        __pyx_v_i = (__pyx_v_i + 1);
+      }
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272
- *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
- * 
- *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+      /* "beam_calc.pyx":375
+ *         while 1:
+ *             while array[i] < x: i += 1
+ *             while x < array[j]: j -= 1             # <<<<<<<<<<<<<<
+ *             if i <= j:
+ *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
  */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(1, 272, __pyx_L1_error)
+      while (1) {
+        __pyx_t_3 = __pyx_v_j;
+        __pyx_t_1 = ((__pyx_v_x < (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_3 * __pyx_v_array.strides[0]) )))) != 0);
+        if (!__pyx_t_1) break;
+        __pyx_v_j = (__pyx_v_j - 1);
+      }
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270
- *             ndim = PyArray_NDIM(self)
- * 
- *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not C contiguous")
+      /* "beam_calc.pyx":376
+ *             while array[i] < x: i += 1
+ *             while x < array[j]: j -= 1
+ *             if i <= j:             # <<<<<<<<<<<<<<
+ *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
+ *                 i += 1; j -= 1
  */
-  }
+      __pyx_t_1 = ((__pyx_v_i <= __pyx_v_j) != 0);
+      if (__pyx_t_1) {
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274
- *                 raise ValueError(u"ndarray is not C contiguous")
- * 
- *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not Fortran contiguous")
+        /* "beam_calc.pyx":377
+ *             while x < array[j]: j -= 1
+ *             if i <= j:
+ *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp             # <<<<<<<<<<<<<<
+ *                 i += 1; j -= 1
+ *             if i > j: break
+ */
+        __pyx_t_3 = __pyx_v_i;
+        __pyx_v_tmp = (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_3 * __pyx_v_array.strides[0]) )));
+        __pyx_t_3 = __pyx_v_j;
+        __pyx_t_4 = __pyx_v_i;
+        *((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_4 * __pyx_v_array.strides[0]) )) = (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_3 * __pyx_v_array.strides[0]) )));
+        __pyx_t_3 = __pyx_v_j;
+        *((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_3 * __pyx_v_array.strides[0]) )) = __pyx_v_tmp;
+
+        /* "beam_calc.pyx":378
+ *             if i <= j:
+ *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
+ *                 i += 1; j -= 1             # <<<<<<<<<<<<<<
+ *             if i > j: break
+ *         if j < k: l = i
  */
-  __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
-  if (__pyx_t_2) {
-  } else {
-    __pyx_t_1 = __pyx_t_2;
-    goto __pyx_L7_bool_binop_done;
-  }
+        __pyx_v_i = (__pyx_v_i + 1);
+        __pyx_v_j = (__pyx_v_j - 1);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275
- * 
- *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):             # <<<<<<<<<<<<<<
- *                 raise ValueError(u"ndarray is not Fortran contiguous")
- * 
+        /* "beam_calc.pyx":376
+ *             while array[i] < x: i += 1
+ *             while x < array[j]: j -= 1
+ *             if i <= j:             # <<<<<<<<<<<<<<
+ *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
+ *                 i += 1; j -= 1
  */
-  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0);
-  __pyx_t_1 = __pyx_t_2;
-  __pyx_L7_bool_binop_done:;
+      }
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274
- *                 raise ValueError(u"ndarray is not C contiguous")
- * 
- *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not Fortran contiguous")
+      /* "beam_calc.pyx":379
+ *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
+ *                 i += 1; j -= 1
+ *             if i > j: break             # <<<<<<<<<<<<<<
+ *         if j < k: l = i
+ *         if k < i: m = j
  */
-  if (unlikely(__pyx_t_1)) {
+      __pyx_t_1 = ((__pyx_v_i > __pyx_v_j) != 0);
+      if (__pyx_t_1) {
+        goto __pyx_L6_break;
+      }
+    }
+    __pyx_L6_break:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276
- *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
- * 
- *             info.buf = PyArray_DATA(self)
+    /* "beam_calc.pyx":380
+ *                 i += 1; j -= 1
+ *             if i > j: break
+ *         if j < k: l = i             # <<<<<<<<<<<<<<
+ *         if k < i: m = j
+ *     return array[k]
  */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(1, 276, __pyx_L1_error)
+    __pyx_t_1 = ((__pyx_v_j < __pyx_v_k) != 0);
+    if (__pyx_t_1) {
+      __pyx_v_l = __pyx_v_i;
+    }
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274
- *                 raise ValueError(u"ndarray is not C contiguous")
+    /* "beam_calc.pyx":381
+ *             if i > j: break
+ *         if j < k: l = i
+ *         if k < i: m = j             # <<<<<<<<<<<<<<
+ *     return array[k]
  * 
- *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not Fortran contiguous")
  */
+    __pyx_t_1 = ((__pyx_v_k < __pyx_v_i) != 0);
+    if (__pyx_t_1) {
+      __pyx_v_m = __pyx_v_j;
+    }
   }
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278
- *                 raise ValueError(u"ndarray is not Fortran contiguous")
+  /* "beam_calc.pyx":382
+ *         if j < k: l = i
+ *         if k < i: m = j
+ *     return array[k]             # <<<<<<<<<<<<<<
  * 
- *             info.buf = PyArray_DATA(self)             # <<<<<<<<<<<<<<
- *             info.ndim = ndim
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ * def make_whitefield(uint_t[:, :, ::1] data, uint8_t[:, ::1] mask):
  */
-  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);
+  __pyx_t_2 = __pyx_v_k;
+  __pyx_r = (*((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_2 * __pyx_v_array.strides[0]) )));
+  goto __pyx_L0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279
+  /* "beam_calc.pyx":366
+ *     return np.asarray(frames)
  * 
- *             info.buf = PyArray_DATA(self)
- *             info.ndim = ndim             # <<<<<<<<<<<<<<
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
- *                 # Allocate new buffer for strides and shape info.
- */
-  __pyx_v_info->ndim = __pyx_v_ndim;
-
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280
- *             info.buf = PyArray_DATA(self)
- *             info.ndim = ndim
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
- *                 # Allocate new buffer for strides and shape info.
- *                 # This is allocated as one block, strides first.
+ * cdef uint_t wirthselect_uint(uint_t[:] array, int k) nogil:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         int_t l = 0, m = array.shape[0] - 1, i, j
  */
-  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
-  if (__pyx_t_1) {
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283
- *                 # Allocate new buffer for strides and shape info.
- *                 # This is allocated as one block, strides first.
- *                 info.strides = <Py_ssize_t*>PyObject_Malloc(sizeof(Py_ssize_t) * 2 * <size_t>ndim)             # <<<<<<<<<<<<<<
- *                 info.shape = info.strides + ndim
- *                 for i in range(ndim):
- */
-    __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim))));
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284
- *                 # This is allocated as one block, strides first.
- *                 info.strides = <Py_ssize_t*>PyObject_Malloc(sizeof(Py_ssize_t) * 2 * <size_t>ndim)
- *                 info.shape = info.strides + ndim             # <<<<<<<<<<<<<<
- *                 for i in range(ndim):
- *                     info.strides[i] = PyArray_STRIDES(self)[i]
+/* "beam_calc.pyx":384
+ *     return array[k]
+ * 
+ * def make_whitefield(uint_t[:, :, ::1] data, uint8_t[:, ::1] mask):             # <<<<<<<<<<<<<<
+ *     """
+ *     Return whitefield based on median filtering of the stack of frames
  */
-    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285
- *                 info.strides = <Py_ssize_t*>PyObject_Malloc(sizeof(Py_ssize_t) * 2 * <size_t>ndim)
- *                 info.shape = info.strides + ndim
- *                 for i in range(ndim):             # <<<<<<<<<<<<<<
- *                     info.strides[i] = PyArray_STRIDES(self)[i]
- *                     info.shape[i] = PyArray_DIMS(self)[i]
- */
-    __pyx_t_4 = __pyx_v_ndim;
-    __pyx_t_5 = __pyx_t_4;
-    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
-      __pyx_v_i = __pyx_t_6;
+/* Python wrapper */
+static PyObject *__pyx_pw_9beam_calc_21make_whitefield(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9beam_calc_20make_whitefield[] = "\n    Return whitefield based on median filtering of the stack of frames\n\n    data - stack of frames\n    mask - bad pixel mask\n    ";
+static PyMethodDef __pyx_mdef_9beam_calc_21make_whitefield = {"make_whitefield", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9beam_calc_21make_whitefield, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9beam_calc_20make_whitefield};
+static PyObject *__pyx_pw_9beam_calc_21make_whitefield(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  __Pyx_memviewslice __pyx_v_data = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_mask = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_whitefield (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_mask,0};
+    PyObject* values[2] = {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  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_data)) != 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_mask)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("make_whitefield", 1, 2, 2, 1); __PYX_ERR(0, 384, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_whitefield") < 0)) __PYX_ERR(0, 384, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_data = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_9beam_calc_uint_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_data.memview)) __PYX_ERR(0, 384, __pyx_L3_error)
+    __pyx_v_mask = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_uint8_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_mask.memview)) __PYX_ERR(0, 384, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("make_whitefield", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 384, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("beam_calc.make_whitefield", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_9beam_calc_20make_whitefield(__pyx_self, __pyx_v_data, __pyx_v_mask);
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286
- *                 info.shape = info.strides + ndim
- *                 for i in range(ndim):
- *                     info.strides[i] = PyArray_STRIDES(self)[i]             # <<<<<<<<<<<<<<
- *                     info.shape[i] = PyArray_DIMS(self)[i]
- *             else:
- */
-      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287
- *                 for i in range(ndim):
- *                     info.strides[i] = PyArray_STRIDES(self)[i]
- *                     info.shape[i] = PyArray_DIMS(self)[i]             # <<<<<<<<<<<<<<
- *             else:
- *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
- */
-      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
-    }
+static PyObject *__pyx_pf_9beam_calc_20make_whitefield(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_data, __Pyx_memviewslice __pyx_v_mask) {
+  __pyx_t_9beam_calc_int_t __pyx_v_a;
+  __pyx_t_9beam_calc_int_t __pyx_v_b;
+  __pyx_t_9beam_calc_int_t __pyx_v_c;
+  __pyx_t_9beam_calc_int_t __pyx_v_i;
+  __pyx_t_9beam_calc_int_t __pyx_v_j;
+  __pyx_t_9beam_calc_int_t __pyx_v_k;
+  __pyx_t_9beam_calc_int_t __pyx_v_max_threads;
+  __Pyx_memviewslice __pyx_v_wf = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_array = { 0, 0, { 0 }, { 0 }, { 0 } };
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_memviewslice __pyx_t_6 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __pyx_t_9beam_calc_int_t __pyx_t_7;
+  __pyx_t_9beam_calc_int_t __pyx_t_8;
+  __pyx_t_9beam_calc_int_t __pyx_t_9;
+  __pyx_t_9beam_calc_int_t __pyx_t_10;
+  __pyx_t_9beam_calc_int_t __pyx_t_11;
+  __pyx_t_9beam_calc_int_t __pyx_t_12;
+  __pyx_t_9beam_calc_int_t __pyx_t_13;
+  __pyx_t_9beam_calc_int_t __pyx_t_14;
+  int __pyx_t_15;
+  __Pyx_memviewslice __pyx_t_16 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_t_17 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("make_whitefield", 0);
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280
- *             info.buf = PyArray_DATA(self)
- *             info.ndim = ndim
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
- *                 # Allocate new buffer for strides and shape info.
- *                 # This is allocated as one block, strides first.
+  /* "beam_calc.pyx":392
+ *     """
+ *     cdef:
+ *         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k             # <<<<<<<<<<<<<<
+ *         int_t max_threads = openmp.omp_get_max_threads()
+ *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
  */
-    goto __pyx_L9;
-  }
+  __pyx_v_a = (__pyx_v_data.shape[0]);
+  __pyx_v_b = (__pyx_v_data.shape[1]);
+  __pyx_v_c = (__pyx_v_data.shape[2]);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289
- *                     info.shape[i] = PyArray_DIMS(self)[i]
- *             else:
- *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)             # <<<<<<<<<<<<<<
- *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
- *             info.suboffsets = NULL
+  /* "beam_calc.pyx":393
+ *     cdef:
+ *         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k
+ *         int_t max_threads = openmp.omp_get_max_threads()             # <<<<<<<<<<<<<<
+ *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
+ *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
  */
-  /*else*/ {
-    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));
+  __pyx_v_max_threads = omp_get_max_threads();
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290
- *             else:
- *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
- *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)             # <<<<<<<<<<<<<<
- *             info.suboffsets = NULL
- *             info.itemsize = PyArray_ITEMSIZE(self)
+  /* "beam_calc.pyx":394
+ *         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k
+ *         int_t max_threads = openmp.omp_get_max_threads()
+ *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)             # <<<<<<<<<<<<<<
+ *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
+ *     for j in prange(b, schedule='guided', nogil=True):
  */
-    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
-  }
-  __pyx_L9:;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_c); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_uint64); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_uint_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_wf = __pyx_t_6;
+  __pyx_t_6.memview = NULL;
+  __pyx_t_6.data = NULL;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291
- *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
- *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
- *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
- *             info.itemsize = PyArray_ITEMSIZE(self)
- *             info.readonly = not PyArray_ISWRITEABLE(self)
+  /* "beam_calc.pyx":395
+ *         int_t max_threads = openmp.omp_get_max_threads()
+ *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
+ *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)             # <<<<<<<<<<<<<<
+ *     for j in prange(b, schedule='guided', nogil=True):
+ *         i = openmp.omp_get_thread_num()
  */
-  __pyx_v_info->suboffsets = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_npy_int64(__pyx_v_max_threads); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
+  __pyx_t_5 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_uint64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_9beam_calc_uint_t(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 395, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_array = __pyx_t_6;
+  __pyx_t_6.memview = NULL;
+  __pyx_t_6.data = NULL;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292
- *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
- *             info.suboffsets = NULL
- *             info.itemsize = PyArray_ITEMSIZE(self)             # <<<<<<<<<<<<<<
- *             info.readonly = not PyArray_ISWRITEABLE(self)
- * 
+  /* "beam_calc.pyx":396
+ *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
+ *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
+ *     for j in prange(b, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         i = openmp.omp_get_thread_num()
+ *         for k in range(c):
  */
-  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      __Pyx_FastGIL_Remember();
+      #endif
+      /*try:*/ {
+        __pyx_t_7 = __pyx_v_b;
+        if ((1 == 0)) abort();
+        {
+            __pyx_t_9beam_calc_int_t __pyx_parallel_temp0 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
+            __pyx_t_9beam_calc_int_t __pyx_parallel_temp1 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
+            __pyx_t_9beam_calc_int_t __pyx_parallel_temp2 = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
+            const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0;
+            PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL;
+            int __pyx_parallel_why;
+            __pyx_parallel_why = 0;
+            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
+                #undef likely
+                #undef unlikely
+                #define likely(x)   (x)
+                #define unlikely(x) (x)
+            #endif
+            __pyx_t_9 = (__pyx_t_7 - 0 + 1 - 1/abs(1)) / 1;
+            if (__pyx_t_9 > 0)
+            {
+                #ifdef _OPENMP
+                #pragma omp parallel private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15) firstprivate(__pyx_t_16, __pyx_t_17) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb)
+                #endif /* _OPENMP */
+                {
+                    #ifdef _OPENMP
+                    #ifdef WITH_THREAD
+                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+                    #endif
+                    Py_BEGIN_ALLOW_THREADS
+                    #endif /* _OPENMP */
+                    #ifdef _OPENMP
+                    #pragma omp for lastprivate(__pyx_v_i) firstprivate(__pyx_v_j) lastprivate(__pyx_v_j) lastprivate(__pyx_v_k) schedule(guided)
+                    #endif /* _OPENMP */
+                    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
+                        if (__pyx_parallel_why < 2)
+                        {
+                            __pyx_v_j = (__pyx_t_9beam_calc_int_t)(0 + 1 * __pyx_t_8);
+                            /* Initialize private variables to invalid values */
+                            __pyx_v_i = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
+                            __pyx_v_k = ((__pyx_t_9beam_calc_int_t)0xbad0bad0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293
- *             info.suboffsets = NULL
- *             info.itemsize = PyArray_ITEMSIZE(self)
- *             info.readonly = not PyArray_ISWRITEABLE(self)             # <<<<<<<<<<<<<<
- * 
- *             cdef int t
+                            /* "beam_calc.pyx":397
+ *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
+ *     for j in prange(b, schedule='guided', nogil=True):
+ *         i = openmp.omp_get_thread_num()             # <<<<<<<<<<<<<<
+ *         for k in range(c):
+ *             if mask[j, k]:
  */
-  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));
+                            __pyx_v_i = omp_get_thread_num();
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296
- * 
- *             cdef int t
- *             cdef char* f = NULL             # <<<<<<<<<<<<<<
- *             cdef dtype descr = <dtype>PyArray_DESCR(self)
- *             cdef int offset
+                            /* "beam_calc.pyx":398
+ *     for j in prange(b, schedule='guided', nogil=True):
+ *         i = openmp.omp_get_thread_num()
+ *         for k in range(c):             # <<<<<<<<<<<<<<
+ *             if mask[j, k]:
+ *                 array[i] = data[:, j, k]
  */
-  __pyx_v_f = NULL;
+                            __pyx_t_10 = __pyx_v_c;
+                            __pyx_t_11 = __pyx_t_10;
+                            for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
+                              __pyx_v_k = __pyx_t_12;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297
- *             cdef int t
- *             cdef char* f = NULL
- *             cdef dtype descr = <dtype>PyArray_DESCR(self)             # <<<<<<<<<<<<<<
- *             cdef int offset
- * 
+                              /* "beam_calc.pyx":399
+ *         i = openmp.omp_get_thread_num()
+ *         for k in range(c):
+ *             if mask[j, k]:             # <<<<<<<<<<<<<<
+ *                 array[i] = data[:, j, k]
+ *                 wf[j, k] = wirthselect_uint(array[i], a // 2)
  */
-  __pyx_t_7 = PyArray_DESCR(__pyx_v_self);
-  __pyx_t_3 = ((PyObject *)__pyx_t_7);
-  __Pyx_INCREF(__pyx_t_3);
-  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
-  __pyx_t_3 = 0;
+                              __pyx_t_13 = __pyx_v_j;
+                              __pyx_t_14 = __pyx_v_k;
+                              __pyx_t_15 = ((*((__pyx_t_9beam_calc_uint8_t *) ( /* dim=1 */ ((char *) (((__pyx_t_9beam_calc_uint8_t *) ( /* dim=0 */ (__pyx_v_mask.data + __pyx_t_13 * __pyx_v_mask.strides[0]) )) + __pyx_t_14)) ))) != 0);
+                              if (__pyx_t_15) {
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300
- *             cdef int offset
- * 
- *             info.obj = self             # <<<<<<<<<<<<<<
- * 
- *             if not PyDataType_HASFIELDS(descr):
+                                /* "beam_calc.pyx":400
+ *         for k in range(c):
+ *             if mask[j, k]:
+ *                 array[i] = data[:, j, k]             # <<<<<<<<<<<<<<
+ *                 wf[j, k] = wirthselect_uint(array[i], a // 2)
+ *             else:
  */
-  __Pyx_INCREF(((PyObject *)__pyx_v_self));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
-  __Pyx_GOTREF(__pyx_v_info->obj);
-  __Pyx_DECREF(__pyx_v_info->obj);
-  __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+                                __pyx_t_16.data = __pyx_v_data.data;
+                                __pyx_t_16.memview = __pyx_v_data.memview;
+                                __PYX_INC_MEMVIEW(&__pyx_t_16, 0);
+                                __pyx_t_16.shape[0] = __pyx_v_data.shape[0];
+__pyx_t_16.strides[0] = __pyx_v_data.strides[0];
+    __pyx_t_16.suboffsets[0] = -1;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302
- *             info.obj = self
- * 
- *             if not PyDataType_HASFIELDS(descr):             # <<<<<<<<<<<<<<
- *                 t = descr.type_num
- *                 if ((descr.byteorder == c'>' and little_endian) or
- */
-  __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0);
-  if (__pyx_t_1) {
+{
+    Py_ssize_t __pyx_tmp_idx = __pyx_v_j;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_data.strides[1];
+        __pyx_t_16.data += __pyx_tmp_idx * __pyx_tmp_stride;
+}
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303
- * 
- *             if not PyDataType_HASFIELDS(descr):
- *                 t = descr.type_num             # <<<<<<<<<<<<<<
- *                 if ((descr.byteorder == c'>' and little_endian) or
- *                     (descr.byteorder == c'<' and not little_endian)):
- */
-    __pyx_t_4 = __pyx_v_descr->type_num;
-    __pyx_v_t = __pyx_t_4;
+{
+    Py_ssize_t __pyx_tmp_idx = __pyx_v_k;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_data.strides[2];
+        __pyx_t_16.data += __pyx_tmp_idx * __pyx_tmp_stride;
+}
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304
- *             if not PyDataType_HASFIELDS(descr):
- *                 t = descr.type_num
- *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
- *                     (descr.byteorder == c'<' and not little_endian)):
- *                     raise ValueError(u"Non-native byte order not supported")
- */
-    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
-    if (!__pyx_t_2) {
-      goto __pyx_L15_next_or;
-    } else {
-    }
-    __pyx_t_2 = (__pyx_v_little_endian != 0);
-    if (!__pyx_t_2) {
-    } else {
-      __pyx_t_1 = __pyx_t_2;
-      goto __pyx_L14_bool_binop_done;
-    }
-    __pyx_L15_next_or:;
+__pyx_t_17.data = __pyx_v_array.data;
+                                __pyx_t_17.memview = __pyx_v_array.memview;
+                                __PYX_INC_MEMVIEW(&__pyx_t_17, 0);
+                                {
+    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_array.strides[0];
+        __pyx_t_17.data += __pyx_tmp_idx * __pyx_tmp_stride;
+}
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305
- *                 t = descr.type_num
- *                 if ((descr.byteorder == c'>' and little_endian) or
- *                     (descr.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
- *                     raise ValueError(u"Non-native byte order not supported")
- *                 if   t == NPY_BYTE:        f = "b"
- */
-    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
-    if (__pyx_t_2) {
-    } else {
-      __pyx_t_1 = __pyx_t_2;
-      goto __pyx_L14_bool_binop_done;
-    }
-    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
-    __pyx_t_1 = __pyx_t_2;
-    __pyx_L14_bool_binop_done:;
+__pyx_t_17.shape[0] = __pyx_v_array.shape[1];
+__pyx_t_17.strides[0] = __pyx_v_array.strides[1];
+    __pyx_t_17.suboffsets[0] = -1;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304
- *             if not PyDataType_HASFIELDS(descr):
- *                 t = descr.type_num
- *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
- *                     (descr.byteorder == c'<' and not little_endian)):
- *                     raise ValueError(u"Non-native byte order not supported")
- */
-    if (unlikely(__pyx_t_1)) {
+if (unlikely(__pyx_memoryview_copy_contents(__pyx_t_16, __pyx_t_17, 1, 1, 0) < 0)) __PYX_ERR(0, 400, __pyx_L8_error)
+                                __PYX_XDEC_MEMVIEW(&__pyx_t_17, 0);
+                                __pyx_t_17.memview = NULL;
+                                __pyx_t_17.data = NULL;
+                                __PYX_XDEC_MEMVIEW(&__pyx_t_16, 0);
+                                __pyx_t_16.memview = NULL;
+                                __pyx_t_16.data = NULL;
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306
- *                 if ((descr.byteorder == c'>' and little_endian) or
- *                     (descr.byteorder == c'<' and not little_endian)):
- *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
- *                 if   t == NPY_BYTE:        f = "b"
- *                 elif t == NPY_UBYTE:       f = "B"
- */
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __PYX_ERR(1, 306, __pyx_L1_error)
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304
- *             if not PyDataType_HASFIELDS(descr):
- *                 t = descr.type_num
- *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
- *                     (descr.byteorder == c'<' and not little_endian)):
- *                     raise ValueError(u"Non-native byte order not supported")
- */
-    }
-
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307
- *                     (descr.byteorder == c'<' and not little_endian)):
- *                     raise ValueError(u"Non-native byte order not supported")
- *                 if   t == NPY_BYTE:        f = "b"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_UBYTE:       f = "B"
- *                 elif t == NPY_SHORT:       f = "h"
- */
-    switch (__pyx_v_t) {
-      case NPY_BYTE:
-      __pyx_v_f = ((char *)"b");
-      break;
-      case NPY_UBYTE:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308
- *                     raise ValueError(u"Non-native byte order not supported")
- *                 if   t == NPY_BYTE:        f = "b"
- *                 elif t == NPY_UBYTE:       f = "B"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_SHORT:       f = "h"
- *                 elif t == NPY_USHORT:      f = "H"
- */
-      __pyx_v_f = ((char *)"B");
-      break;
-      case NPY_SHORT:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309
- *                 if   t == NPY_BYTE:        f = "b"
- *                 elif t == NPY_UBYTE:       f = "B"
- *                 elif t == NPY_SHORT:       f = "h"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_USHORT:      f = "H"
- *                 elif t == NPY_INT:         f = "i"
- */
-      __pyx_v_f = ((char *)"h");
-      break;
-      case NPY_USHORT:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310
- *                 elif t == NPY_UBYTE:       f = "B"
- *                 elif t == NPY_SHORT:       f = "h"
- *                 elif t == NPY_USHORT:      f = "H"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_INT:         f = "i"
- *                 elif t == NPY_UINT:        f = "I"
- */
-      __pyx_v_f = ((char *)"H");
-      break;
-      case NPY_INT:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311
- *                 elif t == NPY_SHORT:       f = "h"
- *                 elif t == NPY_USHORT:      f = "H"
- *                 elif t == NPY_INT:         f = "i"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_UINT:        f = "I"
- *                 elif t == NPY_LONG:        f = "l"
- */
-      __pyx_v_f = ((char *)"i");
-      break;
-      case NPY_UINT:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312
- *                 elif t == NPY_USHORT:      f = "H"
- *                 elif t == NPY_INT:         f = "i"
- *                 elif t == NPY_UINT:        f = "I"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_LONG:        f = "l"
- *                 elif t == NPY_ULONG:       f = "L"
- */
-      __pyx_v_f = ((char *)"I");
-      break;
-      case NPY_LONG:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313
- *                 elif t == NPY_INT:         f = "i"
- *                 elif t == NPY_UINT:        f = "I"
- *                 elif t == NPY_LONG:        f = "l"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_ULONG:       f = "L"
- *                 elif t == NPY_LONGLONG:    f = "q"
- */
-      __pyx_v_f = ((char *)"l");
-      break;
-      case NPY_ULONG:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314
- *                 elif t == NPY_UINT:        f = "I"
- *                 elif t == NPY_LONG:        f = "l"
- *                 elif t == NPY_ULONG:       f = "L"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_LONGLONG:    f = "q"
- *                 elif t == NPY_ULONGLONG:   f = "Q"
- */
-      __pyx_v_f = ((char *)"L");
-      break;
-      case NPY_LONGLONG:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315
- *                 elif t == NPY_LONG:        f = "l"
- *                 elif t == NPY_ULONG:       f = "L"
- *                 elif t == NPY_LONGLONG:    f = "q"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_ULONGLONG:   f = "Q"
- *                 elif t == NPY_FLOAT:       f = "f"
- */
-      __pyx_v_f = ((char *)"q");
-      break;
-      case NPY_ULONGLONG:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316
- *                 elif t == NPY_ULONG:       f = "L"
- *                 elif t == NPY_LONGLONG:    f = "q"
- *                 elif t == NPY_ULONGLONG:   f = "Q"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_FLOAT:       f = "f"
- *                 elif t == NPY_DOUBLE:      f = "d"
- */
-      __pyx_v_f = ((char *)"Q");
-      break;
-      case NPY_FLOAT:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317
- *                 elif t == NPY_LONGLONG:    f = "q"
- *                 elif t == NPY_ULONGLONG:   f = "Q"
- *                 elif t == NPY_FLOAT:       f = "f"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_DOUBLE:      f = "d"
- *                 elif t == NPY_LONGDOUBLE:  f = "g"
- */
-      __pyx_v_f = ((char *)"f");
-      break;
-      case NPY_DOUBLE:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318
- *                 elif t == NPY_ULONGLONG:   f = "Q"
- *                 elif t == NPY_FLOAT:       f = "f"
- *                 elif t == NPY_DOUBLE:      f = "d"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_LONGDOUBLE:  f = "g"
- *                 elif t == NPY_CFLOAT:      f = "Zf"
- */
-      __pyx_v_f = ((char *)"d");
-      break;
-      case NPY_LONGDOUBLE:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319
- *                 elif t == NPY_FLOAT:       f = "f"
- *                 elif t == NPY_DOUBLE:      f = "d"
- *                 elif t == NPY_LONGDOUBLE:  f = "g"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_CFLOAT:      f = "Zf"
- *                 elif t == NPY_CDOUBLE:     f = "Zd"
- */
-      __pyx_v_f = ((char *)"g");
-      break;
-      case NPY_CFLOAT:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320
- *                 elif t == NPY_DOUBLE:      f = "d"
- *                 elif t == NPY_LONGDOUBLE:  f = "g"
- *                 elif t == NPY_CFLOAT:      f = "Zf"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_CDOUBLE:     f = "Zd"
- *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
- */
-      __pyx_v_f = ((char *)"Zf");
-      break;
-      case NPY_CDOUBLE:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321
- *                 elif t == NPY_LONGDOUBLE:  f = "g"
- *                 elif t == NPY_CFLOAT:      f = "Zf"
- *                 elif t == NPY_CDOUBLE:     f = "Zd"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
- *                 elif t == NPY_OBJECT:      f = "O"
- */
-      __pyx_v_f = ((char *)"Zd");
-      break;
-      case NPY_CLONGDOUBLE:
-
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322
- *                 elif t == NPY_CFLOAT:      f = "Zf"
- *                 elif t == NPY_CDOUBLE:     f = "Zd"
- *                 elif t == NPY_CLONGDOUBLE: f = "Zg"             # <<<<<<<<<<<<<<
- *                 elif t == NPY_OBJECT:      f = "O"
- *                 else:
+                                /* "beam_calc.pyx":401
+ *             if mask[j, k]:
+ *                 array[i] = data[:, j, k]
+ *                 wf[j, k] = wirthselect_uint(array[i], a // 2)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 wf[j, k] = 0
  */
-      __pyx_v_f = ((char *)"Zg");
-      break;
-      case NPY_OBJECT:
+                                __pyx_t_17.data = __pyx_v_array.data;
+                                __pyx_t_17.memview = __pyx_v_array.memview;
+                                __PYX_INC_MEMVIEW(&__pyx_t_17, 0);
+                                {
+    Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
+    Py_ssize_t __pyx_tmp_stride = __pyx_v_array.strides[0];
+        __pyx_t_17.data += __pyx_tmp_idx * __pyx_tmp_stride;
+}
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323
- *                 elif t == NPY_CDOUBLE:     f = "Zd"
- *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
- *                 elif t == NPY_OBJECT:      f = "O"             # <<<<<<<<<<<<<<
- *                 else:
- *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
- */
-      __pyx_v_f = ((char *)"O");
-      break;
-      default:
+__pyx_t_17.shape[0] = __pyx_v_array.shape[1];
+__pyx_t_17.strides[0] = __pyx_v_array.strides[1];
+    __pyx_t_17.suboffsets[0] = -1;
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325
- *                 elif t == NPY_OBJECT:      f = "O"
- *                 else:
- *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
- *                 info.format = f
- *                 return
- */
-      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __PYX_ERR(1, 325, __pyx_L1_error)
-      break;
-    }
+__pyx_t_14 = __pyx_v_j;
+                                __pyx_t_13 = __pyx_v_k;
+                                *((__pyx_t_9beam_calc_uint_t *) ( /* dim=1 */ ((char *) (((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_wf.data + __pyx_t_14 * __pyx_v_wf.strides[0]) )) + __pyx_t_13)) )) = __pyx_f_9beam_calc_wirthselect_uint(__pyx_t_17, (__pyx_v_a / 2));
+                                __PYX_XDEC_MEMVIEW(&__pyx_t_17, 0);
+                                __pyx_t_17.memview = NULL;
+                                __pyx_t_17.data = NULL;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326
- *                 else:
- *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
- *                 info.format = f             # <<<<<<<<<<<<<<
- *                 return
- *             else:
+                                /* "beam_calc.pyx":399
+ *         i = openmp.omp_get_thread_num()
+ *         for k in range(c):
+ *             if mask[j, k]:             # <<<<<<<<<<<<<<
+ *                 array[i] = data[:, j, k]
+ *                 wf[j, k] = wirthselect_uint(array[i], a // 2)
  */
-    __pyx_v_info->format = __pyx_v_f;
+                                goto __pyx_L12;
+                              }
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327
- *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
- *                 info.format = f
- *                 return             # <<<<<<<<<<<<<<
+                              /* "beam_calc.pyx":403
+ *                 wf[j, k] = wirthselect_uint(array[i], a // 2)
  *             else:
- *                 info.format = <char*>PyObject_Malloc(_buffer_format_string_len)
+ *                 wf[j, k] = 0             # <<<<<<<<<<<<<<
+ *     return np.asarray(wf)
  */
-    __pyx_r = 0;
-    goto __pyx_L0;
+                              /*else*/ {
+                                __pyx_t_13 = __pyx_v_j;
+                                __pyx_t_14 = __pyx_v_k;
+                                *((__pyx_t_9beam_calc_uint_t *) ( /* dim=1 */ ((char *) (((__pyx_t_9beam_calc_uint_t *) ( /* dim=0 */ (__pyx_v_wf.data + __pyx_t_13 * __pyx_v_wf.strides[0]) )) + __pyx_t_14)) )) = 0;
+                              }
+                              __pyx_L12:;
+                            }
+                            goto __pyx_L14;
+                            __pyx_L8_error:;
+                            {
+                                #ifdef WITH_THREAD
+                                PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+                                #endif
+                                #ifdef _OPENMP
+                                #pragma omp flush(__pyx_parallel_exc_type)
+                                #endif /* _OPENMP */
+                                if (!__pyx_parallel_exc_type) {
+                                  __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
+                                  __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
+                                  __Pyx_GOTREF(__pyx_parallel_exc_type);
+                                }
+                                #ifdef WITH_THREAD
+                                __Pyx_PyGILState_Release(__pyx_gilstate_save);
+                                #endif
+                            }
+                            __pyx_parallel_why = 4;
+                            goto __pyx_L13;
+                            __pyx_L13:;
+                            #ifdef _OPENMP
+                            #pragma omp critical(__pyx_parallel_lastprivates0)
+                            #endif /* _OPENMP */
+                            {
+                                __pyx_parallel_temp0 = __pyx_v_i;
+                                __pyx_parallel_temp1 = __pyx_v_j;
+                                __pyx_parallel_temp2 = __pyx_v_k;
+                            }
+                            __pyx_L14:;
+                            #ifdef _OPENMP
+                            #pragma omp flush(__pyx_parallel_why)
+                            #endif /* _OPENMP */
+                        }
+                    }
+                    #ifdef _OPENMP
+                    Py_END_ALLOW_THREADS
+                    #else
+{
+#ifdef WITH_THREAD
+                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+                    #endif
+                    #endif /* _OPENMP */
+                    /* Clean up any temporaries */
+                    __PYX_XDEC_MEMVIEW(&__pyx_t_16, 0);
+                    __PYX_XDEC_MEMVIEW(&__pyx_t_17, 0);
+                    #ifdef WITH_THREAD
+                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
+                    #endif
+                    #ifndef _OPENMP
+}
+#endif /* _OPENMP */
+                }
+            }
+            if (__pyx_parallel_exc_type) {
+              /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
+              __pyx_parallel_why = 4;
+            }
+            if (__pyx_parallel_why) {
+              __pyx_v_i = __pyx_parallel_temp0;
+              __pyx_v_j = __pyx_parallel_temp1;
+              __pyx_v_k = __pyx_parallel_temp2;
+              switch (__pyx_parallel_why) {
+                    case 4:
+                {
+                    #ifdef WITH_THREAD
+                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+                    #endif
+                    __Pyx_GIVEREF(__pyx_parallel_exc_type);
+                    __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
+                    __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
+                    #ifdef WITH_THREAD
+                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
+                    #endif
+                }
+                goto __pyx_L4_error;
+              }
+            }
+        }
+        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
+            #undef likely
+            #undef unlikely
+            #define likely(x)   __builtin_expect(!!(x), 1)
+            #define unlikely(x) __builtin_expect(!!(x), 0)
+        #endif
+      }
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302
- *             info.obj = self
- * 
- *             if not PyDataType_HASFIELDS(descr):             # <<<<<<<<<<<<<<
- *                 t = descr.type_num
- *                 if ((descr.byteorder == c'>' and little_endian) or
+      /* "beam_calc.pyx":396
+ *         uint_t[:, ::1] wf = np.empty((b, c), dtype=np.uint64)
+ *         uint_t[:, ::1] array = np.empty((max_threads, a), dtype=np.uint64)
+ *     for j in prange(b, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         i = openmp.omp_get_thread_num()
+ *         for k in range(c):
  */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
   }
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329
- *                 return
- *             else:
- *                 info.format = <char*>PyObject_Malloc(_buffer_format_string_len)             # <<<<<<<<<<<<<<
- *                 info.format[0] = c'^' # Native data types, manual alignment
- *                 offset = 0
- */
-  /*else*/ {
-    __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF));
-
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330
+  /* "beam_calc.pyx":404
  *             else:
- *                 info.format = <char*>PyObject_Malloc(_buffer_format_string_len)
- *                 info.format[0] = c'^' # Native data types, manual alignment             # <<<<<<<<<<<<<<
- *                 offset = 0
- *                 f = _util_dtypestring(descr, info.format + 1,
- */
-    (__pyx_v_info->format[0]) = '^';
-
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331
- *                 info.format = <char*>PyObject_Malloc(_buffer_format_string_len)
- *                 info.format[0] = c'^' # Native data types, manual alignment
- *                 offset = 0             # <<<<<<<<<<<<<<
- *                 f = _util_dtypestring(descr, info.format + 1,
- *                                       info.format + _buffer_format_string_len,
- */
-    __pyx_v_offset = 0;
-
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332
- *                 info.format[0] = c'^' # Native data types, manual alignment
- *                 offset = 0
- *                 f = _util_dtypestring(descr, info.format + 1,             # <<<<<<<<<<<<<<
- *                                       info.format + _buffer_format_string_len,
- *                                       &offset)
- */
-    __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error)
-    __pyx_v_f = __pyx_t_9;
-
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335
- *                                       info.format + _buffer_format_string_len,
- *                                       &offset)
- *                 f[0] = c'\0' # Terminate format string             # <<<<<<<<<<<<<<
- * 
- *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *                 wf[j, k] = 0
+ *     return np.asarray(wf)             # <<<<<<<<<<<<<<
  */
-    (__pyx_v_f[0]) = '\x00';
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 404, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 404, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_wf, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_9beam_calc_uint_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_9beam_calc_uint_t, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 404, __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, 404, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258
- *         # experimental exception made for __getbuffer__ and __releasebuffer__
- *         # -- the details of this may change.
- *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
- *             # This implementation of getbuffer is geared towards Cython
- *             # requirements, and does not yet fulfill the PEP.
+  /* "beam_calc.pyx":384
+ *     return array[k]
+ * 
+ * def make_whitefield(uint_t[:, :, ::1] data, uint8_t[:, ::1] mask):             # <<<<<<<<<<<<<<
+ *     """
+ *     Return whitefield based on median filtering of the stack of frames
  */
 
   /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
   __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  if (__pyx_v_info->obj != NULL) {
-    __Pyx_GOTREF(__pyx_v_info->obj);
-    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
-  }
-  goto __pyx_L2;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_16, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
+  __Pyx_AddTraceback("beam_calc.make_whitefield", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
-  if (__pyx_v_info->obj == Py_None) {
-    __Pyx_GOTREF(__pyx_v_info->obj);
-    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
-  }
-  __pyx_L2:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_wf, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_array, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_data, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_mask, 1);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337
- *                 f[0] = c'\0' # Terminate format string
- * 
- *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
- *             if PyArray_HASFIELDS(self):
- *                 PyObject_Free(info.format)
- */
-
-/* Python wrapper */
-static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
-static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
-  __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
-
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338
- * 
- *         def __releasebuffer__(ndarray self, Py_buffer* info):
- *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
- *                 PyObject_Free(info.format)
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
- */
-  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
-  if (__pyx_t_1) {
-
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339
- *         def __releasebuffer__(ndarray self, Py_buffer* info):
- *             if PyArray_HASFIELDS(self):
- *                 PyObject_Free(info.format)             # <<<<<<<<<<<<<<
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
- *                 PyObject_Free(info.strides)
- */
-    PyObject_Free(__pyx_v_info->format);
-
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338
- * 
- *         def __releasebuffer__(ndarray self, Py_buffer* info):
- *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
- *                 PyObject_Free(info.format)
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
- */
-  }
-
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340
- *             if PyArray_HASFIELDS(self):
- *                 PyObject_Free(info.format)
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
- *                 PyObject_Free(info.strides)
- *                 # info.shape was stored after info.strides in the same block
- */
-  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
-  if (__pyx_t_1) {
-
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341
- *                 PyObject_Free(info.format)
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
- *                 PyObject_Free(info.strides)             # <<<<<<<<<<<<<<
- *                 # info.shape was stored after info.strides in the same block
- * 
- */
-    PyObject_Free(__pyx_v_info->strides);
-
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340
- *             if PyArray_HASFIELDS(self):
- *                 PyObject_Free(info.format)
- *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
- *                 PyObject_Free(info.strides)
- *                 # info.shape was stored after info.strides in the same block
- */
-  }
-
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337
- *                 f[0] = c'\0' # Terminate format string
- * 
- *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
- *             if PyArray_HASFIELDS(self):
- *                 PyObject_Free(info.format)
- */
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":742
  * ctypedef npy_cdouble     complex_t
  * 
  * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
@@ -9808,9 +8932,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":822
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":743
  * 
  * cdef inline object PyArray_MultiIterNew1(a):
  *     return PyArray_MultiIterNew(1, <void*>a)             # <<<<<<<<<<<<<<
@@ -9818,13 +8945,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__
  * cdef inline object PyArray_MultiIterNew2(a, b):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error)
+  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 743, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":742
  * ctypedef npy_cdouble     complex_t
  * 
  * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
@@ -9843,7 +8970,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":745
  *     return PyArray_MultiIterNew(1, <void*>a)
  * 
  * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
@@ -9855,9 +8982,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":825
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":746
  * 
  * cdef inline object PyArray_MultiIterNew2(a, b):
  *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)             # <<<<<<<<<<<<<<
@@ -9865,13 +8995,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__
  * cdef inline object PyArray_MultiIterNew3(a, b, c):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error)
+  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 746, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":745
  *     return PyArray_MultiIterNew(1, <void*>a)
  * 
  * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
@@ -9890,7 +9020,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":748
  *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
  * 
  * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
@@ -9902,9 +9032,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":828
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":749
  * 
  * cdef inline object PyArray_MultiIterNew3(a, b, c):
  *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)             # <<<<<<<<<<<<<<
@@ -9912,13 +9045,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__
  * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error)
+  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 749, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":748
  *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
  * 
  * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
@@ -9937,7 +9070,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":751
  *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
  * 
  * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
@@ -9949,9 +9082,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":831
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":752
  * 
  * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
  *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)             # <<<<<<<<<<<<<<
@@ -9959,13 +9095,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__
  * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error)
+  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 752, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":751
  *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
  * 
  * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
@@ -9984,7 +9120,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":754
  *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
  * 
  * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
@@ -9996,9 +9132,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":834
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":755
  * 
  * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
  *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)             # <<<<<<<<<<<<<<
@@ -10006,13 +9145,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__
  * cdef inline tuple PyDataType_SHAPE(dtype d):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error)
+  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 755, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":754
  *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
  * 
  * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
@@ -10031,7 +9170,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":757
  *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
  * 
  * cdef inline tuple PyDataType_SHAPE(dtype d):             # <<<<<<<<<<<<<<
@@ -10045,7 +9184,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__
   int __pyx_t_1;
   __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":758
  * 
  * cdef inline tuple PyDataType_SHAPE(dtype d):
  *     if PyDataType_HASSUBARRAY(d):             # <<<<<<<<<<<<<<
@@ -10055,7 +9194,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__
   __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0);
   if (__pyx_t_1) {
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":838
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":759
  * cdef inline tuple PyDataType_SHAPE(dtype d):
  *     if PyDataType_HASSUBARRAY(d):
  *         return <tuple>d.subarray.shape             # <<<<<<<<<<<<<<
@@ -10067,7 +9206,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__
     __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape);
     goto __pyx_L0;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":758
  * 
  * cdef inline tuple PyDataType_SHAPE(dtype d):
  *     if PyDataType_HASSUBARRAY(d):             # <<<<<<<<<<<<<<
@@ -10076,7 +9215,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__
  */
   }
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":840
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":761
  *         return <tuple>d.subarray.shape
  *     else:
  *         return ()             # <<<<<<<<<<<<<<
@@ -10090,7 +9229,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__
     goto __pyx_L0;
   }
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":757
  *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
  * 
  * cdef inline tuple PyDataType_SHAPE(dtype d):             # <<<<<<<<<<<<<<
@@ -10105,7 +9244,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":763
  *         return ()
  * 
  * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
@@ -10132,9 +9271,12 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
   int __pyx_t_7;
   long __pyx_t_8;
   char *__pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("_util_dtypestring", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":768
  * 
  *     cdef dtype child
  *     cdef int endian_detector = 1             # <<<<<<<<<<<<<<
@@ -10143,7 +9285,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
   __pyx_v_endian_detector = 1;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":848
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":769
  *     cdef dtype child
  *     cdef int endian_detector = 1
  *     cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
@@ -10152,7 +9294,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
   __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":772
  *     cdef tuple fields
  * 
  *     for childname in descr.names:             # <<<<<<<<<<<<<<
@@ -10161,21 +9303,21 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
   if (unlikely(__pyx_v_descr->names == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
-    __PYX_ERR(1, 851, __pyx_L1_error)
+    __PYX_ERR(1, 772, __pyx_L1_error)
   }
   __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
   for (;;) {
     if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
     #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error)
+    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 772, __pyx_L1_error)
     #else
-    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error)
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 772, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     #endif
     __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
     __pyx_t_3 = 0;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":773
  * 
  *     for childname in descr.names:
  *         fields = descr.fields[childname]             # <<<<<<<<<<<<<<
@@ -10184,15 +9326,15 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
     if (unlikely(__pyx_v_descr->fields == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-      __PYX_ERR(1, 852, __pyx_L1_error)
+      __PYX_ERR(1, 773, __pyx_L1_error)
     }
-    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 773, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error)
+    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 773, __pyx_L1_error)
     __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
     __pyx_t_3 = 0;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":853
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":774
  *     for childname in descr.names:
  *         fields = descr.fields[childname]
  *         child, new_offset = fields             # <<<<<<<<<<<<<<
@@ -10205,7 +9347,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
       if (unlikely(size != 2)) {
         if (size > 2) __Pyx_RaiseTooManyValuesError(2);
         else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-        __PYX_ERR(1, 853, __pyx_L1_error)
+        __PYX_ERR(1, 774, __pyx_L1_error)
       }
       #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
       __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
@@ -10213,51 +9355,51 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
       __Pyx_INCREF(__pyx_t_3);
       __Pyx_INCREF(__pyx_t_4);
       #else
-      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error)
+      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 774, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error)
+      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 774, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
       #endif
     } else {
-      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error)
+      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 774, __pyx_L1_error)
     }
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error)
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 774, __pyx_L1_error)
     __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
     __pyx_t_3 = 0;
     __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
     __pyx_t_4 = 0;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":776
  *         child, new_offset = fields
  * 
  *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
  *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
  * 
  */
-    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 776, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error)
+    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 776, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 776, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
     if (unlikely(__pyx_t_6)) {
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":777
  * 
  *         if (end - f) - <int>(new_offset - offset[0]) < 15:
  *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
  * 
  *         if ((child.byteorder == c'>' and little_endian) or
  */
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 777, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
       __Pyx_Raise(__pyx_t_3, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __PYX_ERR(1, 856, __pyx_L1_error)
+      __PYX_ERR(1, 777, __pyx_L1_error)
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":776
  *         child, new_offset = fields
  * 
  *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
@@ -10266,7 +9408,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
     }
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":779
  *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
  * 
  *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
@@ -10286,7 +9428,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
     }
     __pyx_L8_next_or:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":780
  * 
  *         if ((child.byteorder == c'>' and little_endian) or
  *             (child.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
@@ -10303,7 +9445,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
     __pyx_t_6 = __pyx_t_7;
     __pyx_L7_bool_binop_done:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":779
  *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
  * 
  *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
@@ -10312,20 +9454,20 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
     if (unlikely(__pyx_t_6)) {
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":860
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":781
  *         if ((child.byteorder == c'>' and little_endian) or
  *             (child.byteorder == c'<' and not little_endian)):
  *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
  *             # One could encode it in the format string and have Cython
  *             # complain instead, BUT: < and > in format strings also imply
  */
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 781, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
       __Pyx_Raise(__pyx_t_3, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __PYX_ERR(1, 860, __pyx_L1_error)
+      __PYX_ERR(1, 781, __pyx_L1_error)
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":779
  *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
  * 
  *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
@@ -10334,7 +9476,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
     }
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":791
  * 
  *         # Output padding bytes
  *         while offset[0] < new_offset:             # <<<<<<<<<<<<<<
@@ -10342,15 +9484,15 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  *             f += 1
  */
     while (1) {
-      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 791, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 791, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 791, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       if (!__pyx_t_6) break;
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":792
  *         # Output padding bytes
  *         while offset[0] < new_offset:
  *             f[0] = 120 # "x"; pad byte             # <<<<<<<<<<<<<<
@@ -10359,7 +9501,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
       (__pyx_v_f[0]) = 0x78;
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":793
  *         while offset[0] < new_offset:
  *             f[0] = 120 # "x"; pad byte
  *             f += 1             # <<<<<<<<<<<<<<
@@ -10368,7 +9510,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
       __pyx_v_f = (__pyx_v_f + 1);
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":873
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":794
  *             f[0] = 120 # "x"; pad byte
  *             f += 1
  *             offset[0] += 1             # <<<<<<<<<<<<<<
@@ -10379,7 +9521,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
       (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
     }
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":875
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":796
  *             offset[0] += 1
  * 
  *         offset[0] += child.itemsize             # <<<<<<<<<<<<<<
@@ -10389,7 +9531,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
     __pyx_t_8 = 0;
     (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":798
  *         offset[0] += child.itemsize
  * 
  *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
@@ -10399,19 +9541,19 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
     __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
     if (__pyx_t_6) {
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":799
  * 
  *         if not PyDataType_HASFIELDS(child):
  *             t = child.type_num             # <<<<<<<<<<<<<<
  *             if end - f < 5:
  *                 raise RuntimeError(u"Format string allocated too short.")
  */
-      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 799, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
       __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
       __pyx_t_4 = 0;
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":800
  *         if not PyDataType_HASFIELDS(child):
  *             t = child.type_num
  *             if end - f < 5:             # <<<<<<<<<<<<<<
@@ -10421,20 +9563,20 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
       __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
       if (unlikely(__pyx_t_6)) {
 
-        /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880
+        /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":801
  *             t = child.type_num
  *             if end - f < 5:
  *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
  * 
  *             # Until ticket #99 is fixed, use integers to avoid warnings
  */
-        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error)
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 801, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_4);
         __Pyx_Raise(__pyx_t_4, 0, 0, 0);
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __PYX_ERR(1, 880, __pyx_L1_error)
+        __PYX_ERR(1, 801, __pyx_L1_error)
 
-        /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879
+        /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":800
  *         if not PyDataType_HASFIELDS(child):
  *             t = child.type_num
  *             if end - f < 5:             # <<<<<<<<<<<<<<
@@ -10443,252 +9585,252 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":804
  * 
  *             # Until ticket #99 is fixed, use integers to avoid warnings
  *             if   t == NPY_BYTE:        f[0] =  98 #"b"             # <<<<<<<<<<<<<<
  *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
  *             elif t == NPY_SHORT:       f[0] = 104 #"h"
  */
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 804, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error)
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 804, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 804, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 98;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":805
  *             # Until ticket #99 is fixed, use integers to avoid warnings
  *             if   t == NPY_BYTE:        f[0] =  98 #"b"
  *             elif t == NPY_UBYTE:       f[0] =  66 #"B"             # <<<<<<<<<<<<<<
  *             elif t == NPY_SHORT:       f[0] = 104 #"h"
  *             elif t == NPY_USHORT:      f[0] =  72 #"H"
  */
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 805, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 805, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 805, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 66;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":806
  *             if   t == NPY_BYTE:        f[0] =  98 #"b"
  *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
  *             elif t == NPY_SHORT:       f[0] = 104 #"h"             # <<<<<<<<<<<<<<
  *             elif t == NPY_USHORT:      f[0] =  72 #"H"
  *             elif t == NPY_INT:         f[0] = 105 #"i"
  */
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 806, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error)
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 806, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 806, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 0x68;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":807
  *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
  *             elif t == NPY_SHORT:       f[0] = 104 #"h"
  *             elif t == NPY_USHORT:      f[0] =  72 #"H"             # <<<<<<<<<<<<<<
  *             elif t == NPY_INT:         f[0] = 105 #"i"
  *             elif t == NPY_UINT:        f[0] =  73 #"I"
  */
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 807, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 807, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 807, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 72;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":808
  *             elif t == NPY_SHORT:       f[0] = 104 #"h"
  *             elif t == NPY_USHORT:      f[0] =  72 #"H"
  *             elif t == NPY_INT:         f[0] = 105 #"i"             # <<<<<<<<<<<<<<
  *             elif t == NPY_UINT:        f[0] =  73 #"I"
  *             elif t == NPY_LONG:        f[0] = 108 #"l"
  */
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 808, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error)
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 808, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 808, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 0x69;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":809
  *             elif t == NPY_USHORT:      f[0] =  72 #"H"
  *             elif t == NPY_INT:         f[0] = 105 #"i"
  *             elif t == NPY_UINT:        f[0] =  73 #"I"             # <<<<<<<<<<<<<<
  *             elif t == NPY_LONG:        f[0] = 108 #"l"
  *             elif t == NPY_ULONG:       f[0] = 76  #"L"
  */
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 809, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 809, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 809, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 73;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":810
  *             elif t == NPY_INT:         f[0] = 105 #"i"
  *             elif t == NPY_UINT:        f[0] =  73 #"I"
  *             elif t == NPY_LONG:        f[0] = 108 #"l"             # <<<<<<<<<<<<<<
  *             elif t == NPY_ULONG:       f[0] = 76  #"L"
  *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
  */
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 810, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error)
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 810, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 810, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 0x6C;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":811
  *             elif t == NPY_UINT:        f[0] =  73 #"I"
  *             elif t == NPY_LONG:        f[0] = 108 #"l"
  *             elif t == NPY_ULONG:       f[0] = 76  #"L"             # <<<<<<<<<<<<<<
  *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
  *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
  */
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 811, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 811, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 811, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 76;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":812
  *             elif t == NPY_LONG:        f[0] = 108 #"l"
  *             elif t == NPY_ULONG:       f[0] = 76  #"L"
  *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"             # <<<<<<<<<<<<<<
  *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
  *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
  */
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 812, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error)
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 812, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 812, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 0x71;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":813
  *             elif t == NPY_ULONG:       f[0] = 76  #"L"
  *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
  *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"             # <<<<<<<<<<<<<<
  *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
  *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
  */
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 81;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":814
  *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
  *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
  *             elif t == NPY_FLOAT:       f[0] = 102 #"f"             # <<<<<<<<<<<<<<
  *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
  *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
  */
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 814, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error)
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 814, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 814, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 0x66;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":815
  *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
  *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
  *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"             # <<<<<<<<<<<<<<
  *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
  *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
  */
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 815, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 815, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 815, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 0x64;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":816
  *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
  *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
  *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"             # <<<<<<<<<<<<<<
  *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
  *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
  */
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 816, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error)
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 816, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 816, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 0x67;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":817
  *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
  *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
  *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf             # <<<<<<<<<<<<<<
  *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
  *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
  */
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 817, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 817, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 817, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 90;
@@ -10697,18 +9839,18 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":818
  *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
  *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
  *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd             # <<<<<<<<<<<<<<
  *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
  *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
  */
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 818, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error)
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 818, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 818, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 90;
@@ -10717,18 +9859,18 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":819
  *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
  *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
  *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg             # <<<<<<<<<<<<<<
  *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
  *             else:
  */
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 819, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 819, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 819, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       if (__pyx_t_6) {
         (__pyx_v_f[0]) = 90;
@@ -10737,25 +9879,25 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":899
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":820
  *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
  *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
  *             elif t == NPY_OBJECT:      f[0] = 79 #"O"             # <<<<<<<<<<<<<<
  *             else:
  *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
  */
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 820, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error)
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 820, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 820, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       if (likely(__pyx_t_6)) {
         (__pyx_v_f[0]) = 79;
         goto __pyx_L15;
       }
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":822
  *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
  *             else:
  *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
@@ -10763,18 +9905,18 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  *         else:
  */
       /*else*/ {
-        __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error)
+        __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 822, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_3);
-        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error)
+        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 822, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_4);
         __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
         __Pyx_Raise(__pyx_t_4, 0, 0, 0);
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __PYX_ERR(1, 901, __pyx_L1_error)
+        __PYX_ERR(1, 822, __pyx_L1_error)
       }
       __pyx_L15:;
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":902
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":823
  *             else:
  *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
  *             f += 1             # <<<<<<<<<<<<<<
@@ -10783,7 +9925,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  */
       __pyx_v_f = (__pyx_v_f + 1);
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":798
  *         offset[0] += child.itemsize
  * 
  *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
@@ -10793,7 +9935,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
       goto __pyx_L13;
     }
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":827
  *             # Cython ignores struct boundary information ("T{...}"),
  *             # so don't output it
  *             f = _util_dtypestring(child, f, end, offset)             # <<<<<<<<<<<<<<
@@ -10801,12 +9943,12 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
  * 
  */
     /*else*/ {
-      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error)
+      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 827, __pyx_L1_error)
       __pyx_v_f = __pyx_t_9;
     }
     __pyx_L13:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":772
  *     cdef tuple fields
  * 
  *     for childname in descr.names:             # <<<<<<<<<<<<<<
@@ -10816,7 +9958,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
   }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":907
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":828
  *             # so don't output it
  *             f = _util_dtypestring(child, f, end, offset)
  *     return f             # <<<<<<<<<<<<<<
@@ -10826,7 +9968,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
   __pyx_r = __pyx_v_f;
   goto __pyx_L0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":763
  *         return ()
  * 
  * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
@@ -10851,7 +9993,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":943
  *     int _import_umath() except -1
  * 
  * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
@@ -10863,7 +10005,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("set_array_base", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":944
  * 
  * cdef inline void set_array_base(ndarray arr, object base):
  *     Py_INCREF(base) # important to do this before stealing the reference below!             # <<<<<<<<<<<<<<
@@ -10872,7 +10014,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a
  */
   Py_INCREF(__pyx_v_base);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1024
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":945
  * cdef inline void set_array_base(ndarray arr, object base):
  *     Py_INCREF(base) # important to do this before stealing the reference below!
  *     PyArray_SetBaseObject(arr, base)             # <<<<<<<<<<<<<<
@@ -10881,7 +10023,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a
  */
   (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base));
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":943
  *     int _import_umath() except -1
  * 
  * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
@@ -10893,7 +10035,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a
   __Pyx_RefNannyFinishContext();
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":947
  *     PyArray_SetBaseObject(arr, base)
  * 
  * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
@@ -10908,7 +10050,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py
   int __pyx_t_1;
   __Pyx_RefNannySetupContext("get_array_base", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":948
  * 
  * cdef inline object get_array_base(ndarray arr):
  *     base = PyArray_BASE(arr)             # <<<<<<<<<<<<<<
@@ -10917,7 +10059,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py
  */
   __pyx_v_base = PyArray_BASE(__pyx_v_arr);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":949
  * cdef inline object get_array_base(ndarray arr):
  *     base = PyArray_BASE(arr)
  *     if base is NULL:             # <<<<<<<<<<<<<<
@@ -10927,7 +10069,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py
   __pyx_t_1 = ((__pyx_v_base == NULL) != 0);
   if (__pyx_t_1) {
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":950
  *     base = PyArray_BASE(arr)
  *     if base is NULL:
  *         return None             # <<<<<<<<<<<<<<
@@ -10938,7 +10080,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py
     __pyx_r = Py_None; __Pyx_INCREF(Py_None);
     goto __pyx_L0;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":949
  * cdef inline object get_array_base(ndarray arr):
  *     base = PyArray_BASE(arr)
  *     if base is NULL:             # <<<<<<<<<<<<<<
@@ -10947,7 +10089,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py
  */
   }
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1030
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":951
  *     if base is NULL:
  *         return None
  *     return <object>base             # <<<<<<<<<<<<<<
@@ -10959,7 +10101,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py
   __pyx_r = ((PyObject *)__pyx_v_base);
   goto __pyx_L0;
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":947
  *     PyArray_SetBaseObject(arr, base)
  * 
  * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
@@ -10974,12 +10116,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":955
  * # Versions of the import_* functions which are more suitable for
  * # Cython code.
  * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
  *     try:
- *         _import_array()
+ *         __pyx_import_array()
  */
 
 static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
@@ -10993,13 +10135,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
   PyObject *__pyx_t_6 = NULL;
   PyObject *__pyx_t_7 = NULL;
   PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("import_array", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":956
  * # Cython code.
  * cdef inline int import_array() except -1:
  *     try:             # <<<<<<<<<<<<<<
- *         _import_array()
+ *         __pyx_import_array()
  *     except Exception:
  */
   {
@@ -11011,20 +10156,20 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
     __Pyx_XGOTREF(__pyx_t_3);
     /*try:*/ {
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":957
  * cdef inline int import_array() except -1:
  *     try:
- *         _import_array()             # <<<<<<<<<<<<<<
+ *         __pyx_import_array()             # <<<<<<<<<<<<<<
  *     except Exception:
  *         raise ImportError("numpy.core.multiarray failed to import")
  */
-      __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error)
+      __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 957, __pyx_L3_error)
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":956
  * # Cython code.
  * cdef inline int import_array() except -1:
  *     try:             # <<<<<<<<<<<<<<
- *         _import_array()
+ *         __pyx_import_array()
  *     except Exception:
  */
     }
@@ -11034,9 +10179,9 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
     goto __pyx_L8_try_end;
     __pyx_L3_error:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":958
  *     try:
- *         _import_array()
+ *         __pyx_import_array()
  *     except Exception:             # <<<<<<<<<<<<<<
  *         raise ImportError("numpy.core.multiarray failed to import")
  * 
@@ -11044,32 +10189,32 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
     __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
     if (__pyx_t_4) {
       __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error)
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 958, __pyx_L5_except_error)
       __Pyx_GOTREF(__pyx_t_5);
       __Pyx_GOTREF(__pyx_t_6);
       __Pyx_GOTREF(__pyx_t_7);
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038
- *         _import_array()
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":959
+ *         __pyx_import_array()
  *     except Exception:
  *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
  * 
  * cdef inline int import_umath() except -1:
  */
-      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error)
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 959, __pyx_L5_except_error)
       __Pyx_GOTREF(__pyx_t_8);
       __Pyx_Raise(__pyx_t_8, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __PYX_ERR(1, 1038, __pyx_L5_except_error)
+      __PYX_ERR(1, 959, __pyx_L5_except_error)
     }
     goto __pyx_L5_except_error;
     __pyx_L5_except_error:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":956
  * # Cython code.
  * cdef inline int import_array() except -1:
  *     try:             # <<<<<<<<<<<<<<
- *         _import_array()
+ *         __pyx_import_array()
  *     except Exception:
  */
     __Pyx_XGIVEREF(__pyx_t_1);
@@ -11080,12 +10225,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
     __pyx_L8_try_end:;
   }
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":955
  * # Versions of the import_* functions which are more suitable for
  * # Cython code.
  * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
  *     try:
- *         _import_array()
+ *         __pyx_import_array()
  */
 
   /* function exit code */
@@ -11103,7 +10248,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":961
  *         raise ImportError("numpy.core.multiarray failed to import")
  * 
  * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
@@ -11122,9 +10267,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
   PyObject *__pyx_t_6 = NULL;
   PyObject *__pyx_t_7 = NULL;
   PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("import_umath", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":962
  * 
  * cdef inline int import_umath() except -1:
  *     try:             # <<<<<<<<<<<<<<
@@ -11140,16 +10288,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
     __Pyx_XGOTREF(__pyx_t_3);
     /*try:*/ {
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":963
  * cdef inline int import_umath() except -1:
  *     try:
  *         _import_umath()             # <<<<<<<<<<<<<<
  *     except Exception:
  *         raise ImportError("numpy.core.umath failed to import")
  */
-      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error)
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 963, __pyx_L3_error)
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":962
  * 
  * cdef inline int import_umath() except -1:
  *     try:             # <<<<<<<<<<<<<<
@@ -11163,7 +10311,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
     goto __pyx_L8_try_end;
     __pyx_L3_error:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":964
  *     try:
  *         _import_umath()
  *     except Exception:             # <<<<<<<<<<<<<<
@@ -11173,28 +10321,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
     __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
     if (__pyx_t_4) {
       __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error)
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 964, __pyx_L5_except_error)
       __Pyx_GOTREF(__pyx_t_5);
       __Pyx_GOTREF(__pyx_t_6);
       __Pyx_GOTREF(__pyx_t_7);
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":965
  *         _import_umath()
  *     except Exception:
  *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
  * 
  * cdef inline int import_ufunc() except -1:
  */
-      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error)
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 965, __pyx_L5_except_error)
       __Pyx_GOTREF(__pyx_t_8);
       __Pyx_Raise(__pyx_t_8, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __PYX_ERR(1, 1044, __pyx_L5_except_error)
+      __PYX_ERR(1, 965, __pyx_L5_except_error)
     }
     goto __pyx_L5_except_error;
     __pyx_L5_except_error:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":962
  * 
  * cdef inline int import_umath() except -1:
  *     try:             # <<<<<<<<<<<<<<
@@ -11209,7 +10357,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
     __pyx_L8_try_end:;
   }
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":961
  *         raise ImportError("numpy.core.multiarray failed to import")
  * 
  * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
@@ -11232,7 +10380,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
   return __pyx_r;
 }
 
-/* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046
+/* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":967
  *         raise ImportError("numpy.core.umath failed to import")
  * 
  * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
@@ -11251,9 +10399,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
   PyObject *__pyx_t_6 = NULL;
   PyObject *__pyx_t_7 = NULL;
   PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("import_ufunc", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":968
  * 
  * cdef inline int import_ufunc() except -1:
  *     try:             # <<<<<<<<<<<<<<
@@ -11269,16 +10420,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
     __Pyx_XGOTREF(__pyx_t_3);
     /*try:*/ {
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":969
  * cdef inline int import_ufunc() except -1:
  *     try:
  *         _import_umath()             # <<<<<<<<<<<<<<
  *     except Exception:
  *         raise ImportError("numpy.core.umath failed to import")
  */
-      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error)
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 969, __pyx_L3_error)
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":968
  * 
  * cdef inline int import_ufunc() except -1:
  *     try:             # <<<<<<<<<<<<<<
@@ -11292,35 +10443,38 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
     goto __pyx_L8_try_end;
     __pyx_L3_error:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":970
  *     try:
  *         _import_umath()
  *     except Exception:             # <<<<<<<<<<<<<<
  *         raise ImportError("numpy.core.umath failed to import")
+ * 
  */
     __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
     if (__pyx_t_4) {
       __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error)
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 970, __pyx_L5_except_error)
       __Pyx_GOTREF(__pyx_t_5);
       __Pyx_GOTREF(__pyx_t_6);
       __Pyx_GOTREF(__pyx_t_7);
 
-      /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1050
+      /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":971
  *         _import_umath()
  *     except Exception:
  *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef extern from *:
  */
-      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error)
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 971, __pyx_L5_except_error)
       __Pyx_GOTREF(__pyx_t_8);
       __Pyx_Raise(__pyx_t_8, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __PYX_ERR(1, 1050, __pyx_L5_except_error)
+      __PYX_ERR(1, 971, __pyx_L5_except_error)
     }
     goto __pyx_L5_except_error;
     __pyx_L5_except_error:;
 
-    /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047
+    /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":968
  * 
  * cdef inline int import_ufunc() except -1:
  *     try:             # <<<<<<<<<<<<<<
@@ -11335,7 +10489,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
     __pyx_L8_try_end:;
   }
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":967
  *         raise ImportError("numpy.core.umath failed to import")
  * 
  * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
@@ -11374,6 +10528,9 @@ static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, P
   PyObject *__pyx_v_format = 0;
   PyObject *__pyx_v_mode = 0;
   int __pyx_v_allocate_buffer;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
@@ -11512,6 +10669,9 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __
   Py_ssize_t __pyx_t_9;
   PyObject *__pyx_t_10 = NULL;
   Py_ssize_t __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__cinit__", 0);
   __Pyx_INCREF(__pyx_v_format);
 
@@ -11555,7 +10715,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __
  * 
  *         if itemsize <= 0:
  */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 133, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 133, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_Raise(__pyx_t_3, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -11587,7 +10747,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __
  * 
  *         if not isinstance(format, bytes):
  */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 136, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 136, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_Raise(__pyx_t_3, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -11714,7 +10874,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __
  * 
  * 
  */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 148, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 148, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_Raise(__pyx_t_3, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -11988,7 +11148,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __
  * 
  *             if self.dtype_is_object:
  */
-      __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 176, __pyx_L1_error)
+      __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 176, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_10);
       __Pyx_Raise(__pyx_t_10, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
@@ -12135,6 +11295,9 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru
   Py_ssize_t __pyx_t_5;
   int __pyx_t_6;
   Py_ssize_t *__pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   if (__pyx_v_info == NULL) {
     PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
     return -1;
@@ -12229,7 +11392,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru
  *         info.buf = self.data
  *         info.len = self.len
  */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 192, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 192, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_Raise(__pyx_t_3, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -12563,6 +11726,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct _
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__get__", 0);
 
   /* "View.MemoryView":223
@@ -12613,6 +11779,9 @@ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) {
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("get_memview", 0);
 
   /* "View.MemoryView":227
@@ -12751,6 +11920,9 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__getattr__", 0);
 
   /* "View.MemoryView":234
@@ -12816,6 +11988,9 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__getitem__", 0);
 
   /* "View.MemoryView":237
@@ -12880,6 +12055,9 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struc
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__setitem__", 0);
 
   /* "View.MemoryView":240
@@ -12938,6 +12116,9 @@ static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __p
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__reduce_cython__", 0);
 
   /* "(tree fragment)":2
@@ -12946,7 +12127,7 @@ static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __p
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_Raise(__pyx_t_1, 0, 0, 0);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -12993,6 +12174,9 @@ static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__setstate_cython__", 0);
 
   /* "(tree fragment)":4
@@ -13000,7 +12184,7 @@ static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_Raise(__pyx_t_1, 0, 0, 0);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -13040,6 +12224,9 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("array_cwrapper", 0);
 
   /* "View.MemoryView":248
@@ -13207,6 +12394,9 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize
 static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_name = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -13369,6 +12559,9 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi
   int __pyx_t_3;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__reduce_cython__", 0);
 
   /* "(tree fragment)":5
@@ -13595,6 +12788,9 @@ static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_Me
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__setstate_cython__", 0);
 
   /* "(tree fragment)":17
@@ -13724,6 +12920,9 @@ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_ar
   PyObject *__pyx_v_obj = 0;
   int __pyx_v_flags;
   int __pyx_v_dtype_is_object;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
@@ -13804,6 +13003,9 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_
   int __pyx_t_2;
   int __pyx_t_3;
   int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__cinit__", 0);
 
   /* "View.MemoryView":346
@@ -14335,6 +13537,9 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py
   PyObject *__pyx_t_5 = NULL;
   Py_ssize_t __pyx_t_6;
   char *__pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("get_item_pointer", 0);
 
   /* "View.MemoryView":395
@@ -14482,6 +13687,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
   char *__pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__getitem__", 0);
 
   /* "View.MemoryView":404
@@ -14665,6 +13873,9 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__setitem__", 0);
   __Pyx_INCREF(__pyx_v_index);
 
@@ -14685,7 +13896,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit
  * 
  *         have_slices, index = _unellipsify(index, self.view.ndim)
  */
-    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 418, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 418, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_Raise(__pyx_t_2, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -14880,6 +14091,9 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_
   PyObject *__pyx_t_7 = NULL;
   PyObject *__pyx_t_8 = NULL;
   int __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("is_slice", 0);
   __Pyx_INCREF(__pyx_v_obj);
 
@@ -15086,6 +14300,9 @@ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryvi
   int __pyx_t_4;
   int __pyx_t_5;
   int __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("setitem_slice_assignment", 0);
 
   /* "View.MemoryView":445
@@ -15182,6 +14399,9 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor
   PyObject *__pyx_t_10 = NULL;
   PyObject *__pyx_t_11 = NULL;
   PyObject *__pyx_t_12 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0);
 
   /* "View.MemoryView":451
@@ -15455,6 +14675,9 @@ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *_
   __Pyx_RefNannyDeclarations
   char *__pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("setitem_indexed", 0);
 
   /* "View.MemoryView":482
@@ -15524,6 +14747,9 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview
   PyObject *__pyx_t_9 = NULL;
   size_t __pyx_t_10;
   int __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("convert_item_to_object", 0);
 
   /* "View.MemoryView":488
@@ -15718,7 +14944,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview
  *         else:
  *             if len(self.view.format) == 1:
  */
-      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 495, __pyx_L5_except_error)
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 495, __pyx_L5_except_error)
       __Pyx_GOTREF(__pyx_t_6);
       __Pyx_Raise(__pyx_t_6, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -15802,6 +15028,9 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie
   char *__pyx_t_12;
   char *__pyx_t_13;
   char *__pyx_t_14;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("assign_item_from_object", 0);
 
   /* "View.MemoryView":504
@@ -16041,6 +15270,9 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu
   void *__pyx_t_6;
   int __pyx_t_7;
   Py_ssize_t __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   if (__pyx_v_info == NULL) {
     PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
     return -1;
@@ -16074,7 +15306,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu
  * 
  *         if flags & PyBUF_ND:
  */
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 520, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 520, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_Raise(__pyx_t_3, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -16377,6 +15609,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__get__", 0);
 
   /* "View.MemoryView":554
@@ -16516,6 +15751,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru
   Py_ssize_t *__pyx_t_3;
   Py_ssize_t *__pyx_t_4;
   PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__get__", 0);
 
   /* "View.MemoryView":564
@@ -16595,6 +15833,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st
   Py_ssize_t *__pyx_t_4;
   Py_ssize_t *__pyx_t_5;
   PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__get__", 0);
 
   /* "View.MemoryView":568
@@ -16614,7 +15855,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st
  * 
  *         return tuple([stride for stride in self.view.strides[:self.view.ndim]])
  */
-    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 570, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 570, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_Raise(__pyx_t_2, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -16706,6 +15947,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_
   Py_ssize_t *__pyx_t_4;
   Py_ssize_t *__pyx_t_5;
   Py_ssize_t *__pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__get__", 0);
 
   /* "View.MemoryView":576
@@ -16728,7 +15972,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_
     __Pyx_XDECREF(__pyx_r);
     __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 577, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__19, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 577, __pyx_L1_error)
+    __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__17, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 577, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __pyx_r = __pyx_t_3;
@@ -16815,6 +16059,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__get__", 0);
 
   /* "View.MemoryView":583
@@ -16875,6 +16122,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__get__", 0);
 
   /* "View.MemoryView":587
@@ -16937,6 +16187,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__get__", 0);
 
   /* "View.MemoryView":591
@@ -17012,6 +16265,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc
   Py_ssize_t *__pyx_t_4;
   Py_ssize_t *__pyx_t_5;
   PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__get__", 0);
 
   /* "View.MemoryView":595
@@ -17225,6 +16481,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__repr__", 0);
 
   /* "View.MemoryView":612
@@ -17323,6 +16582,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__str__", 0);
 
   /* "View.MemoryView":616
@@ -17402,6 +16664,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16
   __Pyx_RefNannyDeclarations
   __Pyx_memviewslice *__pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("is_c_contig", 0);
 
   /* "View.MemoryView":622
@@ -17476,6 +16741,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18
   __Pyx_RefNannyDeclarations
   __Pyx_memviewslice *__pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("is_f_contig", 0);
 
   /* "View.MemoryView":628
@@ -17550,6 +16818,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20
   __Pyx_RefNannyDeclarations
   __Pyx_memviewslice __pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("copy", 0);
 
   /* "View.MemoryView":633
@@ -17643,6 +16914,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22
   __Pyx_RefNannyDeclarations
   __Pyx_memviewslice __pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("copy_fortran", 0);
 
   /* "View.MemoryView":645
@@ -17730,6 +17004,9 @@ static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struc
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__reduce_cython__", 0);
 
   /* "(tree fragment)":2
@@ -17738,7 +17015,7 @@ static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struc
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_Raise(__pyx_t_1, 0, 0, 0);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -17785,6 +17062,9 @@ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED st
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__setstate_cython__", 0);
 
   /* "(tree fragment)":4
@@ -17792,7 +17072,7 @@ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED st
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_Raise(__pyx_t_1, 0, 0, 0);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -17830,6 +17110,9 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("memoryview_cwrapper", 0);
 
   /* "View.MemoryView":658
@@ -17971,6 +17254,9 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) {
   int __pyx_t_9;
   int __pyx_t_10;
   PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("_unellipsify", 0);
 
   /* "View.MemoryView":671
@@ -18143,9 +17429,9 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) {
         __Pyx_GOTREF(__pyx_t_7);
         { Py_ssize_t __pyx_temp;
           for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) {
-            __Pyx_INCREF(__pyx_slice__22);
-            __Pyx_GIVEREF(__pyx_slice__22);
-            PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__22);
+            __Pyx_INCREF(__pyx_slice__20);
+            __Pyx_GIVEREF(__pyx_slice__20);
+            PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__20);
           }
         }
         __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 682, __pyx_L1_error)
@@ -18178,7 +17464,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) {
  *         else:
  */
       /*else*/ {
-        __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__22); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 685, __pyx_L1_error)
+        __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__20); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 685, __pyx_L1_error)
       }
       __pyx_L7:;
 
@@ -18318,9 +17604,9 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) {
     __Pyx_GOTREF(__pyx_t_3);
     { Py_ssize_t __pyx_temp;
       for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) {
-        __Pyx_INCREF(__pyx_slice__22);
-        __Pyx_GIVEREF(__pyx_slice__22);
-        PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__22);
+        __Pyx_INCREF(__pyx_slice__20);
+        __Pyx_GIVEREF(__pyx_slice__20);
+        PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__20);
       }
     }
     __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 696, __pyx_L1_error)
@@ -18413,6 +17699,9 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __
   Py_ssize_t *__pyx_t_3;
   int __pyx_t_4;
   PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("assert_direct_dimensions", 0);
 
   /* "View.MemoryView":701
@@ -18444,7 +17733,7 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __
  * 
  * 
  */
-      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 703, __pyx_L1_error)
+      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 703, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_5);
       __Pyx_Raise(__pyx_t_5, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
@@ -18520,6 +17809,9 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_
   Py_ssize_t __pyx_t_10;
   int __pyx_t_11;
   Py_ssize_t __pyx_t_12;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("memview_slice", 0);
 
   /* "View.MemoryView":711
@@ -19073,6 +18365,9 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst,
   int __pyx_t_1;
   int __pyx_t_2;
   int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
 
   /* "View.MemoryView":827
  *     cdef bint negative_step
@@ -19859,6 +19154,9 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P
   int __pyx_t_2;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("pybuffer_index", 0);
 
   /* "View.MemoryView":912
@@ -20169,6 +19467,9 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) {
   int __pyx_t_7;
   int __pyx_t_8;
   int __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
 
   /* "View.MemoryView":944
  * @cname('__pyx_memslice_transpose')
@@ -20373,6 +19674,9 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor
   __Pyx_RefNannyDeclarations
   int __pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("convert_item_to_object", 0);
 
   /* "View.MemoryView":980
@@ -20457,6 +19761,9 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo
   int __pyx_t_1;
   int __pyx_t_2;
   PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("assign_item_from_object", 0);
 
   /* "View.MemoryView":986
@@ -20600,6 +19907,9 @@ static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__reduce_cython__", 0);
 
   /* "(tree fragment)":2
@@ -20608,7 +19918,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_Raise(__pyx_t_1, 0, 0, 0);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -20655,6 +19965,9 @@ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUS
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__setstate_cython__", 0);
 
   /* "(tree fragment)":4
@@ -20662,7 +19975,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUS
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_Raise(__pyx_t_1, 0, 0, 0);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -20708,6 +20021,9 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl
   Py_ssize_t *__pyx_t_7;
   Py_ssize_t *__pyx_t_8;
   Py_ssize_t __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("memoryview_fromslice", 0);
 
   /* "View.MemoryView":1007
@@ -21083,6 +20399,9 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p
   int __pyx_t_1;
   int __pyx_t_2;
   PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("get_slice_from_memview", 0);
 
   /* "View.MemoryView":1055
@@ -21307,6 +20626,9 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("memoryview_copy", 0);
 
   /* "View.MemoryView":1083
@@ -21369,6 +20691,9 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview
   PyObject *(*__pyx_t_3)(char *);
   int (*__pyx_t_4)(char *, PyObject *);
   PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0);
 
   /* "View.MemoryView":1094
@@ -22211,6 +21536,9 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src,
   struct __pyx_memoryview_obj *__pyx_t_4;
   int __pyx_t_5;
   int __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
 
   /* "View.MemoryView":1219
  *     cdef void *result
@@ -22458,6 +21786,9 @@ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   #ifdef WITH_THREAD
   PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
   #endif
@@ -22543,6 +21874,9 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg,
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   #ifdef WITH_THREAD
   PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
   #endif
@@ -22625,6 +21959,9 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) {
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   #ifdef WITH_THREAD
   PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
   #endif
@@ -22742,6 +22079,9 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_
   int __pyx_t_6;
   void *__pyx_t_7;
   int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
 
   /* "View.MemoryView":1276
  *     Check for overlapping memory and verify the shapes.
@@ -23818,6 +23158,9 @@ static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *_
   PyObject *__pyx_v___pyx_type = 0;
   long __pyx_v___pyx_checksum;
   PyObject *__pyx_v___pyx_state = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0);
@@ -23895,6 +23238,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
   int __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0);
 
   /* "(tree fragment)":4
@@ -24083,6 +23429,9 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__
   PyObject *__pyx_t_6 = NULL;
   PyObject *__pyx_t_7 = NULL;
   PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0);
 
   /* "(tree fragment)":12
@@ -24224,9 +23573,9 @@ static void __pyx_tp_dealloc_array(PyObject *o) {
   {
     PyObject *etype, *eval, *etb;
     PyErr_Fetch(&etype, &eval, &etb);
-    ++Py_REFCNT(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
     __pyx_array___dealloc__(o);
-    --Py_REFCNT(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
     PyErr_Restore(etype, eval, etb);
   }
   Py_CLEAR(p->mode);
@@ -24535,9 +23884,9 @@ static void __pyx_tp_dealloc_memoryview(PyObject *o) {
   {
     PyObject *etype, *eval, *etb;
     PyErr_Fetch(&etype, &eval, &etb);
-    ++Py_REFCNT(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
     __pyx_memoryview___dealloc__(o);
-    --Py_REFCNT(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
     PyErr_Restore(etype, eval, etb);
   }
   Py_CLEAR(p->obj);
@@ -24785,9 +24134,9 @@ static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) {
   {
     PyObject *etype, *eval, *etb;
     PyErr_Fetch(&etype, &eval, &etb);
-    ++Py_REFCNT(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
     __pyx_memoryviewslice___dealloc__(o);
-    --Py_REFCNT(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
     PyErr_Restore(etype, eval, etb);
   }
   Py_CLEAR(p->from_object);
@@ -24990,16 +24339,17 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1},
   {&__pyx_n_s_asarray, __pyx_k_asarray, sizeof(__pyx_k_asarray), 0, 0, 1, 1},
   {&__pyx_n_s_atn, __pyx_k_atn, sizeof(__pyx_k_atn), 0, 0, 1, 1},
+  {&__pyx_n_s_atn0, __pyx_k_atn0, sizeof(__pyx_k_atn0), 0, 0, 1, 1},
   {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1},
-  {&__pyx_n_s_barcode, __pyx_k_barcode, sizeof(__pyx_k_barcode), 0, 0, 1, 1},
+  {&__pyx_n_s_barcode_1d, __pyx_k_barcode_1d, sizeof(__pyx_k_barcode_1d), 0, 0, 1, 1},
+  {&__pyx_n_s_barcode_2d, __pyx_k_barcode_2d, sizeof(__pyx_k_barcode_2d), 0, 0, 1, 1},
   {&__pyx_n_s_barcode_steps, __pyx_k_barcode_steps, sizeof(__pyx_k_barcode_steps), 0, 0, 1, 1},
   {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1},
-  {&__pyx_n_s_bc_t, __pyx_k_bc_t, sizeof(__pyx_k_bc_t), 0, 0, 1, 1},
   {&__pyx_n_s_beam_calc, __pyx_k_beam_calc, sizeof(__pyx_k_beam_calc), 0, 0, 1, 1},
   {&__pyx_kp_s_beam_calc_pyx, __pyx_k_beam_calc_pyx, sizeof(__pyx_k_beam_calc_pyx), 0, 0, 1, 0},
-  {&__pyx_n_s_bm_dx, __pyx_k_bm_dx, sizeof(__pyx_k_bm_dx), 0, 0, 1, 1},
   {&__pyx_n_s_br_dx, __pyx_k_br_dx, sizeof(__pyx_k_br_dx), 0, 0, 1, 1},
   {&__pyx_n_s_br_n, __pyx_k_br_n, sizeof(__pyx_k_br_n), 0, 0, 1, 1},
+  {&__pyx_n_s_br_tr, __pyx_k_br_tr, sizeof(__pyx_k_br_tr), 0, 0, 1, 1},
   {&__pyx_n_s_bs_max, __pyx_k_bs_max, sizeof(__pyx_k_bs_max), 0, 0, 1, 1},
   {&__pyx_n_s_bs_min, __pyx_k_bs_min, sizeof(__pyx_k_bs_min), 0, 0, 1, 1},
   {&__pyx_n_s_bx_arr, __pyx_k_bx_arr, sizeof(__pyx_k_bx_arr), 0, 0, 1, 1},
@@ -25053,8 +24403,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1},
   {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
   {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
-  {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
-  {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0},
   {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1},
   {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1},
   {&__pyx_n_s_nf, __pyx_k_nf, sizeof(__pyx_k_nf), 0, 0, 1, 1},
@@ -25109,16 +24457,18 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_wf, __pyx_k_wf, sizeof(__pyx_k_wf), 0, 0, 1, 1},
   {&__pyx_n_s_wf0, __pyx_k_wf0, sizeof(__pyx_k_wf0), 0, 0, 1, 1},
   {&__pyx_n_s_wl, __pyx_k_wl, sizeof(__pyx_k_wl), 0, 0, 1, 1},
+  {&__pyx_n_s_x0, __pyx_k_x0, sizeof(__pyx_k_x0), 0, 0, 1, 1},
+  {&__pyx_n_s_x1, __pyx_k_x1, sizeof(__pyx_k_x1), 0, 0, 1, 1},
   {&__pyx_n_s_x_arr, __pyx_k_x_arr, sizeof(__pyx_k_x_arr), 0, 0, 1, 1},
   {&__pyx_n_s_xx_arr, __pyx_k_xx_arr, sizeof(__pyx_k_xx_arr), 0, 0, 1, 1},
   {&__pyx_n_s_z, __pyx_k_z, sizeof(__pyx_k_z), 0, 0, 1, 1},
   {0, 0, 0, 0, 0, 0, 0}
 };
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 90, __pyx_L1_error)
-  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error)
-  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error)
-  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error)
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 128, __pyx_L1_error)
+  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 777, __pyx_L1_error)
+  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 781, __pyx_L1_error)
+  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 959, __pyx_L1_error)
   __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(2, 148, __pyx_L1_error)
   __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(2, 151, __pyx_L1_error)
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(2, 2, __pyx_L1_error)
@@ -25134,82 +24484,60 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272
- *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":777
  * 
- *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
  */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 272, __pyx_L1_error)
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 777, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple_);
   __Pyx_GIVEREF(__pyx_tuple_);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276
- *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
- *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
- *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
- * 
- *             info.buf = PyArray_DATA(self)
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":781
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
  */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 276, __pyx_L1_error)
+  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 781, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__2);
   __Pyx_GIVEREF(__pyx_tuple__2);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306
- *                 if ((descr.byteorder == c'>' and little_endian) or
- *                     (descr.byteorder == c'<' and not little_endian)):
- *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
- *                 if   t == NPY_BYTE:        f = "b"
- *                 elif t == NPY_UBYTE:       f = "B"
- */
-  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 306, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__3);
-  __Pyx_GIVEREF(__pyx_tuple__3);
-
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856
- * 
- *         if (end - f) - <int>(new_offset - offset[0]) < 15:
- *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
- * 
- *         if ((child.byteorder == c'>' and little_endian) or
- */
-  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 856, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__4);
-  __Pyx_GIVEREF(__pyx_tuple__4);
-
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":801
  *             t = child.type_num
  *             if end - f < 5:
  *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
  * 
  *             # Until ticket #99 is fixed, use integers to avoid warnings
  */
-  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 880, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__5);
-  __Pyx_GIVEREF(__pyx_tuple__5);
+  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 801, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038
- *         _import_array()
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":959
+ *         __pyx_import_array()
  *     except Exception:
  *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
  * 
  * cdef inline int import_umath() except -1:
  */
-  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 1038, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__6);
-  __Pyx_GIVEREF(__pyx_tuple__6);
+  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 959, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
 
-  /* "../../../../../../anaconda3/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044
+  /* "../../../../../../anaconda3/lib/python3.7/site-packages/numpy/__init__.pxd":965
  *         _import_umath()
  *     except Exception:
  *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
  * 
  * cdef inline int import_ufunc() except -1:
  */
-  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 1044, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__7);
-  __Pyx_GIVEREF(__pyx_tuple__7);
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 965, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
 
   /* "View.MemoryView":133
  * 
@@ -25218,9 +24546,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * 
  *         if itemsize <= 0:
  */
-  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(2, 133, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__8);
-  __Pyx_GIVEREF(__pyx_tuple__8);
+  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(2, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
 
   /* "View.MemoryView":136
  * 
@@ -25229,9 +24557,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * 
  *         if not isinstance(format, bytes):
  */
-  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(2, 136, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__9);
-  __Pyx_GIVEREF(__pyx_tuple__9);
+  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(2, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
 
   /* "View.MemoryView":148
  * 
@@ -25240,9 +24568,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * 
  * 
  */
-  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 148, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__10);
-  __Pyx_GIVEREF(__pyx_tuple__10);
+  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(2, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
 
   /* "View.MemoryView":176
  *             self.data = <char *>malloc(self.len)
@@ -25251,9 +24579,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * 
  *             if self.dtype_is_object:
  */
-  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(2, 176, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__11);
-  __Pyx_GIVEREF(__pyx_tuple__11);
+  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(2, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__9);
+  __Pyx_GIVEREF(__pyx_tuple__9);
 
   /* "View.MemoryView":192
  *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
@@ -25262,9 +24590,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  *         info.buf = self.data
  *         info.len = self.len
  */
-  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(2, 192, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__12);
-  __Pyx_GIVEREF(__pyx_tuple__12);
+  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
@@ -25272,18 +24600,18 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(2, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__13);
-  __Pyx_GIVEREF(__pyx_tuple__13);
+  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
 
   /* "(tree fragment)":4
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(2, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__14);
-  __Pyx_GIVEREF(__pyx_tuple__14);
+  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
 
   /* "View.MemoryView":418
  *     def __setitem__(memoryview self, object index, object value):
@@ -25292,9 +24620,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * 
  *         have_slices, index = _unellipsify(index, self.view.ndim)
  */
-  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(2, 418, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__15);
-  __Pyx_GIVEREF(__pyx_tuple__15);
+  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(2, 418, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
 
   /* "View.MemoryView":495
  *             result = struct.unpack(self.view.format, bytesitem)
@@ -25303,9 +24631,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  *         else:
  *             if len(self.view.format) == 1:
  */
-  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(2, 495, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__16);
-  __Pyx_GIVEREF(__pyx_tuple__16);
+  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(2, 495, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
 
   /* "View.MemoryView":520
  *     def __getbuffer__(self, Py_buffer *info, int flags):
@@ -25314,9 +24642,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * 
  *         if flags & PyBUF_ND:
  */
-  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(2, 520, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__17);
-  __Pyx_GIVEREF(__pyx_tuple__17);
+  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(2, 520, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
 
   /* "View.MemoryView":570
  *         if self.view.strides == NULL:
@@ -25325,9 +24653,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * 
  *         return tuple([stride for stride in self.view.strides[:self.view.ndim]])
  */
-  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(2, 570, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__18);
-  __Pyx_GIVEREF(__pyx_tuple__18);
+  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(2, 570, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
 
   /* "View.MemoryView":577
  *     def suboffsets(self):
@@ -25336,12 +24664,12 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * 
  *         return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
  */
-  __pyx_tuple__19 = PyTuple_New(1); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(2, 577, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__19);
+  __pyx_tuple__17 = PyTuple_New(1); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(2, 577, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
   __Pyx_INCREF(__pyx_int_neg_1);
   __Pyx_GIVEREF(__pyx_int_neg_1);
-  PyTuple_SET_ITEM(__pyx_tuple__19, 0, __pyx_int_neg_1);
-  __Pyx_GIVEREF(__pyx_tuple__19);
+  PyTuple_SET_ITEM(__pyx_tuple__17, 0, __pyx_int_neg_1);
+  __Pyx_GIVEREF(__pyx_tuple__17);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
@@ -25349,18 +24677,18 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(2, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__20);
-  __Pyx_GIVEREF(__pyx_tuple__20);
+  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__18);
+  __Pyx_GIVEREF(__pyx_tuple__18);
 
   /* "(tree fragment)":4
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(2, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__21);
-  __Pyx_GIVEREF(__pyx_tuple__21);
+  __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__19);
+  __Pyx_GIVEREF(__pyx_tuple__19);
 
   /* "View.MemoryView":682
  *         if item is Ellipsis:
@@ -25369,9 +24697,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  *                 seen_ellipsis = True
  *             else:
  */
-  __pyx_slice__22 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__22)) __PYX_ERR(2, 682, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_slice__22);
-  __Pyx_GIVEREF(__pyx_slice__22);
+  __pyx_slice__20 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__20)) __PYX_ERR(2, 682, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice__20);
+  __Pyx_GIVEREF(__pyx_slice__20);
 
   /* "View.MemoryView":703
  *     for suboffset in suboffsets[:ndim]:
@@ -25380,9 +24708,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * 
  * 
  */
-  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(2, 703, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__23);
-  __Pyx_GIVEREF(__pyx_tuple__23);
+  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(2, 703, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
@@ -25390,138 +24718,150 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(2, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__24);
-  __Pyx_GIVEREF(__pyx_tuple__24);
+  __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__22);
+  __Pyx_GIVEREF(__pyx_tuple__22);
 
   /* "(tree fragment)":4
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  * def __setstate_cython__(self, __pyx_state):
  *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(2, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__25);
-  __Pyx_GIVEREF(__pyx_tuple__25);
+  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
 
-  /* "beam_calc.pyx":122
- *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
+  /* "beam_calc.pyx":60
  * 
- * def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
+ * 
+ * def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,             # <<<<<<<<<<<<<<
+ *          float_t defoc, float_t alpha, float_t x0):
  *     """
- *     1D Fraunhofer diffraction calculation (without the coefficient)
  */
-  __pyx_tuple__26 = PyTuple_Pack(7, __pyx_n_s_wf0, __pyx_n_s_x_arr, __pyx_n_s_xx_arr, __pyx_n_s_dist, __pyx_n_s_wl, __pyx_n_s_a, __pyx_n_s_wf); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __pyx_tuple__24 = PyTuple_Pack(10, __pyx_n_s_x_arr, __pyx_n_s_wl, __pyx_n_s_ap, __pyx_n_s_focus, __pyx_n_s_defoc, __pyx_n_s_alpha, __pyx_n_s_x0, __pyx_n_s_a, __pyx_n_s_i, __pyx_n_s_wave_arr); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+  __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(7, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_beam_calc_pyx, __pyx_n_s_lens, 60, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 60, __pyx_L1_error)
+
+  /* "beam_calc.pyx":104
+ *     return re + 1j * im
+ * 
+ * def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):             # <<<<<<<<<<<<<<
+ *     """
+ *     Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)
+ */
+  __pyx_tuple__26 = PyTuple_Pack(7, __pyx_n_s_x_arr, __pyx_n_s_z, __pyx_n_s_wl, __pyx_n_s_ap, __pyx_n_s_a, __pyx_n_s_i, __pyx_n_s_wave_arr); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 104, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__26);
   __Pyx_GIVEREF(__pyx_tuple__26);
-  __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 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_beam_calc_pyx, __pyx_n_s_fraunhofer_1d, 122, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(4, 0, 7, 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_beam_calc_pyx, __pyx_n_s_aperture, 104, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 104, __pyx_L1_error)
 
-  /* "beam_calc.pyx":138
- *     return np.asarray(wf)
+  /* "beam_calc.pyx":140
+ *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
  * 
- * def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
+ * def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
- *     1D Fraunhofer diffraction calculation for an array of wavefronts (without the coefficient)
+ *     1D Fraunhofer diffraction calculation (without the coefficient)
  */
-  __pyx_tuple__28 = PyTuple_Pack(9, __pyx_n_s_wf0, __pyx_n_s_x_arr, __pyx_n_s_xx_arr, __pyx_n_s_dist, __pyx_n_s_wl, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_i, __pyx_n_s_wf); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __pyx_tuple__28 = PyTuple_Pack(7, __pyx_n_s_wf0, __pyx_n_s_x_arr, __pyx_n_s_xx_arr, __pyx_n_s_dist, __pyx_n_s_wl, __pyx_n_s_a, __pyx_n_s_wf); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 140, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__28);
   __Pyx_GIVEREF(__pyx_tuple__28);
-  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(5, 0, 9, 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_beam_calc_pyx, __pyx_n_s_fraunhofer_2d, 138, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 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_beam_calc_pyx, __pyx_n_s_fraunhofer_1d, 140, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 140, __pyx_L1_error)
 
-  /* "beam_calc.pyx":155
+  /* "beam_calc.pyx":156
  *     return np.asarray(wf)
  * 
- * def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
+ * def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
- *     1D Fresnel diffraction calculation (without the coefficient)
+ *     1D Fraunhofer diffraction calculation for an array of wavefronts (without the coefficient)
  */
-  __pyx_tuple__30 = PyTuple_Pack(7, __pyx_n_s_wf0, __pyx_n_s_x_arr, __pyx_n_s_xx_arr, __pyx_n_s_dist, __pyx_n_s_wl, __pyx_n_s_a, __pyx_n_s_wf); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __pyx_tuple__30 = PyTuple_Pack(9, __pyx_n_s_wf0, __pyx_n_s_x_arr, __pyx_n_s_xx_arr, __pyx_n_s_dist, __pyx_n_s_wl, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_i, __pyx_n_s_wf); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 156, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__30);
   __Pyx_GIVEREF(__pyx_tuple__30);
-  __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 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_beam_calc_pyx, __pyx_n_s_fresnel_1d, 155, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(5, 0, 9, 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_beam_calc_pyx, __pyx_n_s_fraunhofer_2d, 156, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 156, __pyx_L1_error)
 
-  /* "beam_calc.pyx":171
- *     return np.asarray(wf)
+  /* "beam_calc.pyx":193
+ *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
  * 
- * def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
+ * def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
- *     1D Fresnel diffraction calculation for an array of wavefronts (without the coefficient)
+ *     1D Fresnel diffraction calculation (without the coefficient)
  */
-  __pyx_tuple__32 = PyTuple_Pack(9, __pyx_n_s_wf0, __pyx_n_s_x_arr, __pyx_n_s_xx_arr, __pyx_n_s_dist, __pyx_n_s_wl, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_i, __pyx_n_s_wf); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __pyx_tuple__32 = PyTuple_Pack(7, __pyx_n_s_wf0, __pyx_n_s_x_arr, __pyx_n_s_xx_arr, __pyx_n_s_dist, __pyx_n_s_wl, __pyx_n_s_a, __pyx_n_s_wf); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 193, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__32);
   __Pyx_GIVEREF(__pyx_tuple__32);
-  __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(5, 0, 9, 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_beam_calc_pyx, __pyx_n_s_fresnel_2d, 171, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 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_beam_calc_pyx, __pyx_n_s_fresnel_1d, 193, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 193, __pyx_L1_error)
 
-  /* "beam_calc.pyx":188
+  /* "beam_calc.pyx":209
  *     return np.asarray(wf)
  * 
- * def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):             # <<<<<<<<<<<<<<
+ * def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
- *     Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)
+ *     1D Fresnel diffraction calculation for an array of wavefronts (without the coefficient)
  */
-  __pyx_tuple__34 = PyTuple_Pack(7, __pyx_n_s_x_arr, __pyx_n_s_z, __pyx_n_s_wl, __pyx_n_s_ap, __pyx_n_s_a, __pyx_n_s_i, __pyx_n_s_wave_arr); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __pyx_tuple__34 = PyTuple_Pack(9, __pyx_n_s_wf0, __pyx_n_s_x_arr, __pyx_n_s_xx_arr, __pyx_n_s_dist, __pyx_n_s_wl, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_i, __pyx_n_s_wf); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 209, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__34);
   __Pyx_GIVEREF(__pyx_tuple__34);
-  __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(4, 0, 7, 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_beam_calc_pyx, __pyx_n_s_aperture, 188, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(5, 0, 9, 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_beam_calc_pyx, __pyx_n_s_fresnel_2d, 209, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 209, __pyx_L1_error)
 
-  /* "beam_calc.pyx":204
- *     return np.asarray(wave_arr)
+  /* "beam_calc.pyx":226
+ *     return np.asarray(wf)
  * 
- * def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,             # <<<<<<<<<<<<<<
- *          float_t defoc, float_t alpha):
+ * def barcode_steps(float_t x0, float_t x1, float_t br_dx, float_t rd):             # <<<<<<<<<<<<<<
  *     """
+ *     Barcode bars' coordinates generation with random deviation
  */
-  __pyx_tuple__36 = PyTuple_Pack(9, __pyx_n_s_x_arr, __pyx_n_s_wl, __pyx_n_s_ap, __pyx_n_s_focus, __pyx_n_s_defoc, __pyx_n_s_alpha, __pyx_n_s_a, __pyx_n_s_i, __pyx_n_s_wave_arr); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 204, __pyx_L1_error)
+  __pyx_tuple__36 = PyTuple_Pack(10, __pyx_n_s_x0, __pyx_n_s_x1, __pyx_n_s_br_dx, __pyx_n_s_rd, __pyx_n_s_br_n, __pyx_n_s_i, __pyx_n_s_r, __pyx_n_s_bs_min, __pyx_n_s_bs_max, __pyx_n_s_bx_arr); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 226, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__36);
   __Pyx_GIVEREF(__pyx_tuple__36);
-  __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(6, 0, 9, 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_beam_calc_pyx, __pyx_n_s_lens, 204, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 204, __pyx_L1_error)
+  __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(4, 0, 10, 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_beam_calc_pyx, __pyx_n_s_barcode_steps, 226, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 226, __pyx_L1_error)
 
-  /* "beam_calc.pyx":224
- *     return np.asarray(wave_arr)
+  /* "beam_calc.pyx":286
+ *         br_tr[i] = sqrt(1 + tr)
  * 
- * def barcode_steps(float_t bm_dx, float_t br_dx, float_t rd, float_t ss, int_t nf):             # <<<<<<<<<<<<<<
+ * def barcode_1d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn0, float_t atn):             # <<<<<<<<<<<<<<
  *     """
- *     Barcode bars' coordinates generation with random deviation
+ *     Barcode transmission array for a scan
  */
-  __pyx_tuple__38 = PyTuple_Pack(11, __pyx_n_s_bm_dx, __pyx_n_s_br_dx, __pyx_n_s_rd, __pyx_n_s_ss, __pyx_n_s_nf, __pyx_n_s_br_n, __pyx_n_s_i, __pyx_n_s_r, __pyx_n_s_bs_min, __pyx_n_s_bs_max, __pyx_n_s_bx_arr); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __pyx_tuple__38 = PyTuple_Pack(7, __pyx_n_s_x_arr, __pyx_n_s_bx_arr, __pyx_n_s_sgm, __pyx_n_s_atn0, __pyx_n_s_atn, __pyx_n_s_a, __pyx_n_s_br_tr); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 286, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__38);
   __Pyx_GIVEREF(__pyx_tuple__38);
-  __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(5, 0, 11, 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_beam_calc_pyx, __pyx_n_s_barcode_steps, 224, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 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_beam_calc_pyx, __pyx_n_s_barcode_1d, 286, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 286, __pyx_L1_error)
 
-  /* "beam_calc.pyx":283
- *         br_tr[i] = sqrt(1 - atn / 2 + atn * tr)
+  /* "beam_calc.pyx":303
+ *     return np.asarray(br_tr)
  * 
- * def barcode(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn, float_t ss, int_t nf):             # <<<<<<<<<<<<<<
+ * def barcode_2d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm,             # <<<<<<<<<<<<<<
+ *                float_t atn0, float_t atn, float_t ss, int_t nf):
  *     """
- *     Barcode transmission array for a scan
  */
-  __pyx_tuple__40 = PyTuple_Pack(9, __pyx_n_s_x_arr, __pyx_n_s_bx_arr, __pyx_n_s_sgm, __pyx_n_s_atn, __pyx_n_s_ss, __pyx_n_s_nf, __pyx_n_s_a, __pyx_n_s_i, __pyx_n_s_bc_t); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 283, __pyx_L1_error)
+  __pyx_tuple__40 = PyTuple_Pack(10, __pyx_n_s_x_arr, __pyx_n_s_bx_arr, __pyx_n_s_sgm, __pyx_n_s_atn0, __pyx_n_s_atn, __pyx_n_s_ss, __pyx_n_s_nf, __pyx_n_s_a, __pyx_n_s_i, __pyx_n_s_br_tr); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 303, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__40);
   __Pyx_GIVEREF(__pyx_tuple__40);
-  __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(6, 0, 9, 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_beam_calc_pyx, __pyx_n_s_barcode, 283, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 283, __pyx_L1_error)
+  __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(7, 0, 10, 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_beam_calc_pyx, __pyx_n_s_barcode_2d, 303, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 303, __pyx_L1_error)
 
-  /* "beam_calc.pyx":323
+  /* "beam_calc.pyx":344
  *     gsl_rng_free(r)
  * 
  * def make_frames(float_t[:, ::1] i_x, float_t[::1] i_y, float_t[::1] sc_x, float_t[::1] sc_y, float_t pix_size):             # <<<<<<<<<<<<<<
  *     """
  *     Generate intensity frames with Poisson noise from x and y coordinate wavefront profiles
  */
-  __pyx_tuple__42 = PyTuple_Pack(13, __pyx_n_s_i_x, __pyx_n_s_i_y, __pyx_n_s_sc_x, __pyx_n_s_sc_y, __pyx_n_s_pix_size, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_i, __pyx_n_s_frames, __pyx_n_s_i_ys, __pyx_n_s_r, __pyx_n_s_seed); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 323, __pyx_L1_error)
+  __pyx_tuple__42 = PyTuple_Pack(13, __pyx_n_s_i_x, __pyx_n_s_i_y, __pyx_n_s_sc_x, __pyx_n_s_sc_y, __pyx_n_s_pix_size, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_i, __pyx_n_s_frames, __pyx_n_s_i_ys, __pyx_n_s_r, __pyx_n_s_seed); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 344, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__42);
   __Pyx_GIVEREF(__pyx_tuple__42);
-  __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 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_beam_calc_pyx, __pyx_n_s_make_frames, 323, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(0, 323, __pyx_L1_error)
+  __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 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_beam_calc_pyx, __pyx_n_s_make_frames, 344, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(0, 344, __pyx_L1_error)
 
-  /* "beam_calc.pyx":363
+  /* "beam_calc.pyx":384
  *     return array[k]
  * 
  * def make_whitefield(uint_t[:, :, ::1] data, uint8_t[:, ::1] mask):             # <<<<<<<<<<<<<<
  *     """
  *     Return whitefield based on median filtering of the stack of frames
  */
-  __pyx_tuple__44 = PyTuple_Pack(11, __pyx_n_s_data, __pyx_n_s_mask, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_max_threads, __pyx_n_s_wf, __pyx_n_s_array); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 363, __pyx_L1_error)
+  __pyx_tuple__44 = PyTuple_Pack(11, __pyx_n_s_data, __pyx_n_s_mask, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_max_threads, __pyx_n_s_wf, __pyx_n_s_array); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 384, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__44);
   __Pyx_GIVEREF(__pyx_tuple__44);
-  __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 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_beam_calc_pyx, __pyx_n_s_make_whitefield, 363, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 363, __pyx_L1_error)
+  __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 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_beam_calc_pyx, __pyx_n_s_make_whitefield, 384, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 384, __pyx_L1_error)
 
   /* "View.MemoryView":286
  *         return self.name
@@ -25651,6 +24991,9 @@ static int __Pyx_modinit_function_export_code(void) {
 
 static int __Pyx_modinit_type_init_code(void) {
   __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
   /*--- Type init code ---*/
   __pyx_vtabptr_array = &__pyx_vtable_array;
@@ -25714,6 +25057,9 @@ static int __Pyx_modinit_type_init_code(void) {
 static int __Pyx_modinit_type_import_code(void) {
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
   /*--- Type import code ---*/
   __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error)
@@ -25727,18 +25073,18 @@ static int __Pyx_modinit_type_import_code(void) {
   __Pyx_ImportType_CheckSize_Warn);
    if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error)
+  __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 207, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore);
-   if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error)
-  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error)
-  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error)
+   if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 207, __pyx_L1_error)
+  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore);
+   if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 230, __pyx_L1_error)
+  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore);
+   if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 234, __pyx_L1_error)
   __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore);
-   if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error)
-  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 918, __pyx_L1_error)
+   if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 246, __pyx_L1_error)
+  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore);
+   if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 839, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -25765,17 +25111,19 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
-#if PY_MAJOR_VERSION < 3
-#ifdef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC void
-#else
+#ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#elif PY_MAJOR_VERSION < 3
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" void
+#else
+#define __Pyx_PyMODINIT_FUNC void
 #endif
 #else
-#ifdef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC PyObject *
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
 #else
-#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#define __Pyx_PyMODINIT_FUNC PyObject *
 #endif
 #endif
 
@@ -25858,6 +25206,9 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_beam_calc(PyObject *__pyx_pyinit_m
 {
   PyObject *__pyx_t_1 = NULL;
   static PyThread_type_lock __pyx_t_2[8];
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   __Pyx_RefNannyDeclarations
   #if CYTHON_PEP489_MULTI_PHASE_INIT
   if (__pyx_m) {
@@ -25946,15 +25297,15 @@ if (!__Pyx_RefNanny) {
   }
   #endif
   /*--- Builtin init code ---*/
-  if (__Pyx_InitCachedBuiltins() < 0) goto __pyx_L1_error;
+  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   /*--- Constants init code ---*/
-  if (__Pyx_InitCachedConstants() < 0) goto __pyx_L1_error;
+  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   /*--- Global type/function init code ---*/
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
   (void)__Pyx_modinit_function_export_code();
-  if (unlikely(__Pyx_modinit_type_init_code() != 0)) goto __pyx_L1_error;
-  if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error;
+  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
   (void)__Pyx_modinit_variable_import_code();
   (void)__Pyx_modinit_function_import_code();
   /*--- Execution code ---*/
@@ -25973,124 +25324,136 @@ if (!__Pyx_RefNanny) {
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "beam_calc.pyx":122
- *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
+  /* "beam_calc.pyx":60
+ * 
+ * 
+ * def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,             # <<<<<<<<<<<<<<
+ *          float_t defoc, float_t alpha, float_t x0):
+ *     """
+ */
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_1lens, 0, __pyx_n_s_lens, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_lens, __pyx_t_1) < 0) __PYX_ERR(0, 60, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "beam_calc.pyx":104
+ *     return re + 1j * im
+ * 
+ * def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):             # <<<<<<<<<<<<<<
+ *     """
+ *     Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)
+ */
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_3aperture, 0, __pyx_n_s_aperture, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_aperture, __pyx_t_1) < 0) __PYX_ERR(0, 104, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "beam_calc.pyx":140
+ *         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
  * 
  * def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
  *     1D Fraunhofer diffraction calculation (without the coefficient)
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_1fraunhofer_1d, 0, __pyx_n_s_fraunhofer_1d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_5fraunhofer_1d, 0, __pyx_n_s_fraunhofer_1d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fraunhofer_1d, __pyx_t_1) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fraunhofer_1d, __pyx_t_1) < 0) __PYX_ERR(0, 140, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "beam_calc.pyx":138
+  /* "beam_calc.pyx":156
  *     return np.asarray(wf)
  * 
  * def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
  *     1D Fraunhofer diffraction calculation for an array of wavefronts (without the coefficient)
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_3fraunhofer_2d, 0, __pyx_n_s_fraunhofer_2d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_7fraunhofer_2d, 0, __pyx_n_s_fraunhofer_2d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fraunhofer_2d, __pyx_t_1) < 0) __PYX_ERR(0, 138, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fraunhofer_2d, __pyx_t_1) < 0) __PYX_ERR(0, 156, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "beam_calc.pyx":155
- *     return np.asarray(wf)
+  /* "beam_calc.pyx":193
+ *         wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
  * 
  * def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
  *     1D Fresnel diffraction calculation (without the coefficient)
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_5fresnel_1d, 0, __pyx_n_s_fresnel_1d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_9fresnel_1d, 0, __pyx_n_s_fresnel_1d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fresnel_1d, __pyx_t_1) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fresnel_1d, __pyx_t_1) < 0) __PYX_ERR(0, 193, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "beam_calc.pyx":171
+  /* "beam_calc.pyx":209
  *     return np.asarray(wf)
  * 
  * def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):             # <<<<<<<<<<<<<<
  *     """
  *     1D Fresnel diffraction calculation for an array of wavefronts (without the coefficient)
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_7fresnel_2d, 0, __pyx_n_s_fresnel_2d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_11fresnel_2d, 0, __pyx_n_s_fresnel_2d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fresnel_2d, __pyx_t_1) < 0) __PYX_ERR(0, 171, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fresnel_2d, __pyx_t_1) < 0) __PYX_ERR(0, 209, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "beam_calc.pyx":188
+  /* "beam_calc.pyx":226
  *     return np.asarray(wf)
  * 
- * def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):             # <<<<<<<<<<<<<<
- *     """
- *     Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)
- */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_9aperture, 0, __pyx_n_s_aperture, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_aperture, __pyx_t_1) < 0) __PYX_ERR(0, 188, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  /* "beam_calc.pyx":204
- *     return np.asarray(wave_arr)
- * 
- * def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,             # <<<<<<<<<<<<<<
- *          float_t defoc, float_t alpha):
+ * def barcode_steps(float_t x0, float_t x1, float_t br_dx, float_t rd):             # <<<<<<<<<<<<<<
  *     """
+ *     Barcode bars' coordinates generation with random deviation
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_11lens, 0, __pyx_n_s_lens, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_13barcode_steps, 0, __pyx_n_s_barcode_steps, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_lens, __pyx_t_1) < 0) __PYX_ERR(0, 204, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_barcode_steps, __pyx_t_1) < 0) __PYX_ERR(0, 226, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "beam_calc.pyx":224
- *     return np.asarray(wave_arr)
+  /* "beam_calc.pyx":286
+ *         br_tr[i] = sqrt(1 + tr)
  * 
- * def barcode_steps(float_t bm_dx, float_t br_dx, float_t rd, float_t ss, int_t nf):             # <<<<<<<<<<<<<<
+ * def barcode_1d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn0, float_t atn):             # <<<<<<<<<<<<<<
  *     """
- *     Barcode bars' coordinates generation with random deviation
+ *     Barcode transmission array for a scan
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_13barcode_steps, 0, __pyx_n_s_barcode_steps, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_15barcode_1d, 0, __pyx_n_s_barcode_1d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_barcode_steps, __pyx_t_1) < 0) __PYX_ERR(0, 224, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_barcode_1d, __pyx_t_1) < 0) __PYX_ERR(0, 286, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "beam_calc.pyx":283
- *         br_tr[i] = sqrt(1 - atn / 2 + atn * tr)
+  /* "beam_calc.pyx":303
+ *     return np.asarray(br_tr)
  * 
- * def barcode(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn, float_t ss, int_t nf):             # <<<<<<<<<<<<<<
+ * def barcode_2d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm,             # <<<<<<<<<<<<<<
+ *                float_t atn0, float_t atn, float_t ss, int_t nf):
  *     """
- *     Barcode transmission array for a scan
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_15barcode, 0, __pyx_n_s_barcode, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 283, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_17barcode_2d, 0, __pyx_n_s_barcode_2d, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 303, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_barcode, __pyx_t_1) < 0) __PYX_ERR(0, 283, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_barcode_2d, __pyx_t_1) < 0) __PYX_ERR(0, 303, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "beam_calc.pyx":323
+  /* "beam_calc.pyx":344
  *     gsl_rng_free(r)
  * 
  * def make_frames(float_t[:, ::1] i_x, float_t[::1] i_y, float_t[::1] sc_x, float_t[::1] sc_y, float_t pix_size):             # <<<<<<<<<<<<<<
  *     """
  *     Generate intensity frames with Poisson noise from x and y coordinate wavefront profiles
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_17make_frames, 0, __pyx_n_s_make_frames, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__43)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 323, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_19make_frames, 0, __pyx_n_s_make_frames, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__43)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 344, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_frames, __pyx_t_1) < 0) __PYX_ERR(0, 323, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_frames, __pyx_t_1) < 0) __PYX_ERR(0, 344, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "beam_calc.pyx":363
+  /* "beam_calc.pyx":384
  *     return array[k]
  * 
  * def make_whitefield(uint_t[:, :, ::1] data, uint8_t[:, ::1] mask):             # <<<<<<<<<<<<<<
  *     """
  *     Return whitefield based on median filtering of the stack of frames
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9beam_calc_19make_whitefield, 0, __pyx_n_s_make_whitefield, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__45)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 363, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9beam_calc_21make_whitefield, 0, __pyx_n_s_make_whitefield, NULL, __pyx_n_s_beam_calc, __pyx_d, ((PyObject *)__pyx_codeobj__45)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_whitefield, __pyx_t_1) < 0) __PYX_ERR(0, 363, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_whitefield, __pyx_t_1) < 0) __PYX_ERR(0, 384, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "beam_calc.pyx":1
@@ -26388,7 +25751,7 @@ static int __Pyx_ParseOptionalKeywords(
         }
         name = first_kw_arg;
         #if PY_MAJOR_VERSION < 3
-        if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
+        if (likely(PyString_Check(key))) {
             while (*name) {
                 if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                         && _PyString_Eq(**name, key)) {
@@ -26415,7 +25778,7 @@ static int __Pyx_ParseOptionalKeywords(
             while (*name) {
                 int cmp = (**name == key) ? 0 :
                 #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                    (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
+                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                 #endif
                     PyUnicode_Compare(**name, key);
                 if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
@@ -26431,7 +25794,7 @@ static int __Pyx_ParseOptionalKeywords(
                 while (argname != first_kw_arg) {
                     int cmp = (**argname == key) ? 0 :
                     #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                        (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
+                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                     #endif
                         PyUnicode_Compare(**argname, key);
                     if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
@@ -26791,7 +26154,7 @@ __Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview,
     int i, retval=-1;
     Py_buffer *buf = &memview->view;
     __Pyx_RefNannySetupContext("init_memviewslice", 0);
-    if (memviewslice->memview || memviewslice->data) {
+    if (unlikely(memviewslice->memview || memviewslice->data)) {
         PyErr_SetString(PyExc_ValueError,
             "memviewslice is already initialized!");
         goto fail;
@@ -26870,13 +26233,13 @@ __Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno)
 {
     int first_time;
     struct __pyx_memoryview_obj *memview = memslice->memview;
-    if (!memview || (PyObject *) memview == Py_None)
+    if (unlikely(!memview || (PyObject *) memview == Py_None))
         return;
-    if (__pyx_get_slice_count(memview) < 0)
+    if (unlikely(__pyx_get_slice_count(memview) < 0))
         __pyx_fatalerror("Acquisition count is %d (line %d)",
                          __pyx_get_slice_count(memview), lineno);
     first_time = __pyx_add_acquisition_count(memview) == 0;
-    if (first_time) {
+    if (unlikely(first_time)) {
         if (have_gil) {
             Py_INCREF((PyObject *) memview);
         } else {
@@ -26890,18 +26253,16 @@ static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice,
                                              int have_gil, int lineno) {
     int last_time;
     struct __pyx_memoryview_obj *memview = memslice->memview;
-    if (!memview ) {
-        return;
-    } else if ((PyObject *) memview == Py_None) {
+    if (unlikely(!memview || (PyObject *) memview == Py_None)) {
         memslice->memview = NULL;
         return;
     }
-    if (__pyx_get_slice_count(memview) <= 0)
+    if (unlikely(__pyx_get_slice_count(memview) <= 0))
         __pyx_fatalerror("Acquisition count is %d (line %d)",
                          __pyx_get_slice_count(memview), lineno);
     last_time = __pyx_sub_acquisition_count(memview) == 1;
     memslice->data = NULL;
-    if (last_time) {
+    if (unlikely(last_time)) {
         if (have_gil) {
             Py_CLEAR(memslice->memview);
         } else {
@@ -26938,6 +26299,61 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 }
 #endif
 
+/* DictGetItem */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
+    PyObject *value;
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (!PyErr_Occurred()) {
+            if (unlikely(PyTuple_Check(key))) {
+                PyObject* args = PyTuple_Pack(1, key);
+                if (likely(args)) {
+                    PyErr_SetObject(PyExc_KeyError, args);
+                    Py_DECREF(args);
+                }
+            } else {
+                PyErr_SetObject(PyExc_KeyError, key);
+            }
+        }
+        return NULL;
+    }
+    Py_INCREF(value);
+    return value;
+}
+#endif
+
+/* RaiseTooManyValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* RaiseNoneIterError */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+}
+
+/* ExtTypeTest */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (likely(__Pyx_TypeCheck(obj, type)))
+        return 1;
+    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
+                 Py_TYPE(obj)->tp_name, type->tp_name);
+    return 0;
+}
+
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
@@ -27097,61 +26513,6 @@ bad:
 }
 #endif
 
-/* DictGetItem */
-#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
-static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
-    PyObject *value;
-    value = PyDict_GetItemWithError(d, key);
-    if (unlikely(!value)) {
-        if (!PyErr_Occurred()) {
-            if (unlikely(PyTuple_Check(key))) {
-                PyObject* args = PyTuple_Pack(1, key);
-                if (likely(args)) {
-                    PyErr_SetObject(PyExc_KeyError, args);
-                    Py_DECREF(args);
-                }
-            } else {
-                PyErr_SetObject(PyExc_KeyError, key);
-            }
-        }
-        return NULL;
-    }
-    Py_INCREF(value);
-    return value;
-}
-#endif
-
-/* RaiseTooManyValuesToUnpack */
-static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
-    PyErr_Format(PyExc_ValueError,
-                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
-}
-
-/* RaiseNeedMoreValuesToUnpack */
-static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
-    PyErr_Format(PyExc_ValueError,
-                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
-                 index, (index == 1) ? "" : "s");
-}
-
-/* RaiseNoneIterError */
-static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
-    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
-}
-
-/* ExtTypeTest */
-static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
-    if (unlikely(!type)) {
-        PyErr_SetString(PyExc_SystemError, "Missing type object");
-        return 0;
-    }
-    if (likely(__Pyx_TypeCheck(obj, type)))
-        return 1;
-    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
-                 Py_TYPE(obj)->tp_name, type->tp_name);
-    return 0;
-}
-
 /* GetTopmostException */
 #if CYTHON_USE_EXC_INFO_STACK
 static _PyErr_StackItem *
@@ -27628,9 +26989,9 @@ static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
         if (stop < 0)
             stop += length;
     }
+    if (unlikely(stop <= start))
+        return __Pyx_NewRef(__pyx_empty_unicode);
     length = stop - start;
-    if (unlikely(length <= 0))
-        return PyUnicode_FromUnicode(NULL, 0);
     cstring += start;
     if (decode_func) {
         return decode_func(cstring, length, errors);
@@ -27719,7 +27080,7 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
     {
         #if PY_MAJOR_VERSION >= 3
         if (level == -1) {
-            if (strchr(__Pyx_MODULE_NAME, '.')) {
+            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
                 module = PyImport_ImportModuleLevelObject(
                     name, global_dict, empty_dict, list, 1);
                 if (!module) {
@@ -28083,6 +27444,28 @@ bad:
     return -1;
 }
 
+/* PyObjectGetAttrStrNoError */
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+}
+
 /* SetupReduce */
 static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
   int ret;
@@ -28128,15 +27511,23 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
 #endif
         reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
         if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
-            reduce_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_cython); if (unlikely(!reduce_cython)) goto __PYX_BAD;
-            ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-            ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
+            if (likely(reduce_cython)) {
+                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            } else if (reduce == object_reduce || PyErr_Occurred()) {
+                goto __PYX_BAD;
+            }
             setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
             if (!setstate) PyErr_Clear();
             if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
-                setstate_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate_cython); if (unlikely(!setstate_cython)) goto __PYX_BAD;
-                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
+                if (likely(setstate_cython)) {
+                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                } else if (!setstate || PyErr_Occurred()) {
+                    goto __PYX_BAD;
+                }
             }
             PyType_Modified((PyTypeObject*)type_obj);
         }
@@ -28259,7 +27650,7 @@ bad:
     goto done;
 }
 
-/* CythonFunction */
+/* CythonFunctionShared */
 #include <structmember.h>
 static PyObject *
 __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
@@ -28566,10 +27957,9 @@ static PyMethodDef __pyx_CyFunction_methods[] = {
 #else
 #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist)
 #endif
-static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname,
-                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
-    __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type);
-    if (op == NULL)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    if (unlikely(op == NULL))
         return NULL;
     op->flags = flags;
     __Pyx_CyFunction_weakreflist(op) = NULL;
@@ -28596,7 +27986,6 @@ static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int f
     op->defaults_kwdict = NULL;
     op->defaults_getter = NULL;
     op->func_annotations = NULL;
-    PyObject_GC_Track(op);
     return (PyObject *) op;
 }
 static int
@@ -28659,6 +28048,7 @@ static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit,
 }
 static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type)
 {
+#if PY_MAJOR_VERSION < 3
     __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
     if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) {
         Py_INCREF(func);
@@ -28671,6 +28061,7 @@ static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObj
     }
     if (obj == Py_None)
         obj = NULL;
+#endif
     return __Pyx_PyMethod_New(func, obj, type);
 }
 static PyObject*
@@ -28863,6 +28254,19 @@ static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, Py
     Py_INCREF(dict);
 }
 
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
+}
+
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
 static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
@@ -29073,7 +28477,6 @@ bad:
 #if PY_MAJOR_VERSION < 3
 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
     if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
-        if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);
         if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags);
         if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags);
     PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
@@ -29087,7 +28490,6 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) {
         return;
     }
     if ((0)) {}
-        else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view);
     view->obj = NULL;
     Py_DECREF(obj);
 }
@@ -29503,9 +28905,7 @@ static PyObject *
 __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
 {
     const char *ts = *tsp;
-    int i = 0, number;
-    int ndim = ctx->head->field->type->ndim;
-;
+    int i = 0, number, ndim;
     ++ts;
     if (ctx->new_count != 1) {
         PyErr_SetString(PyExc_ValueError,
@@ -29513,6 +28913,7 @@ __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
         return NULL;
     }
     if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+    ndim = ctx->head->field->type->ndim;
     while (*ts && *ts != ')') {
         switch (*ts) {
             case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
@@ -29642,8 +29043,8 @@ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const cha
       case 'l': case 'L': case 'q': case 'Q':
       case 'f': case 'd': case 'g':
       case 'O': case 'p':
-        if (ctx->enc_type == *ts && got_Z == ctx->is_complex &&
-            ctx->enc_packmode == ctx->new_packmode) {
+        if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) &&
+            (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) {
           ctx->enc_count += ctx->new_count;
           ctx->new_count = 1;
           got_Z = 0;
@@ -29729,13 +29130,13 @@ __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec)
     if (buf->strides) {
         if (spec & __Pyx_MEMVIEW_CONTIG) {
             if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) {
-                if (buf->strides[dim] != sizeof(void *)) {
+                if (unlikely(buf->strides[dim] != sizeof(void *))) {
                     PyErr_Format(PyExc_ValueError,
                                  "Buffer is not indirectly contiguous "
                                  "in dimension %d.", dim);
                     goto fail;
                 }
-            } else if (buf->strides[dim] != buf->itemsize) {
+            } else if (unlikely(buf->strides[dim] != buf->itemsize)) {
                 PyErr_SetString(PyExc_ValueError,
                                 "Buffer and memoryview are not contiguous "
                                 "in the same dimension.");
@@ -29746,7 +29147,7 @@ __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec)
             Py_ssize_t stride = buf->strides[dim];
             if (stride < 0)
                 stride = -stride;
-            if (stride < buf->itemsize) {
+            if (unlikely(stride < buf->itemsize)) {
                 PyErr_SetString(PyExc_ValueError,
                                 "Buffer and memoryview are not contiguous "
                                 "in the same dimension.");
@@ -29754,17 +29155,17 @@ __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec)
             }
         }
     } else {
-        if (spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1) {
+        if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) {
             PyErr_Format(PyExc_ValueError,
                          "C-contiguous buffer is not contiguous in "
                          "dimension %d", dim);
             goto fail;
-        } else if (spec & (__Pyx_MEMVIEW_PTR)) {
+        } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) {
             PyErr_Format(PyExc_ValueError,
                          "C-contiguous buffer is not indirect in "
                          "dimension %d", dim);
             goto fail;
-        } else if (buf->suboffsets) {
+        } else if (unlikely(buf->suboffsets)) {
             PyErr_SetString(PyExc_ValueError,
                             "Buffer exposes suboffsets but no strides");
             goto fail;
@@ -29778,7 +29179,7 @@ static int
 __pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec)
 {
     if (spec & __Pyx_MEMVIEW_DIRECT) {
-        if (buf->suboffsets && buf->suboffsets[dim] >= 0) {
+        if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) {
             PyErr_Format(PyExc_ValueError,
                          "Buffer not compatible with direct access "
                          "in dimension %d.", dim);
@@ -29786,7 +29187,7 @@ __pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec
         }
     }
     if (spec & __Pyx_MEMVIEW_PTR) {
-        if (!buf->suboffsets || (buf->suboffsets[dim] < 0)) {
+        if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) {
             PyErr_Format(PyExc_ValueError,
                          "Buffer is not indirectly accessible "
                          "in dimension %d.", dim);
@@ -29804,9 +29205,7 @@ __pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag)
     if (c_or_f_flag & __Pyx_IS_F_CONTIG) {
         Py_ssize_t stride = 1;
         for (i = 0; i < ndim; i++) {
-            if (stride * buf->itemsize != buf->strides[i] &&
-                    buf->shape[i] > 1)
-            {
+            if (unlikely(stride * buf->itemsize != buf->strides[i]  &&  buf->shape[i] > 1)) {
                 PyErr_SetString(PyExc_ValueError,
                     "Buffer not fortran contiguous.");
                 goto fail;
@@ -29816,8 +29215,7 @@ __pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag)
     } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) {
         Py_ssize_t stride = 1;
         for (i = ndim - 1; i >- 1; i--) {
-            if (stride * buf->itemsize != buf->strides[i] &&
-                    buf->shape[i] > 1) {
+            if (unlikely(stride * buf->itemsize != buf->strides[i]  &&  buf->shape[i] > 1)) {
                 PyErr_SetString(PyExc_ValueError,
                     "Buffer not C contiguous.");
                 goto fail;
@@ -29858,7 +29256,7 @@ static int __Pyx_ValidateAndInit_memviewslice(
             goto fail;
     }
     buf = &memview->view;
-    if (buf->ndim != ndim) {
+    if (unlikely(buf->ndim != ndim)) {
         PyErr_Format(PyExc_ValueError,
                 "Buffer has wrong number of dimensions (expected %d, got %d)",
                 ndim, buf->ndim);
@@ -29866,9 +29264,9 @@ static int __Pyx_ValidateAndInit_memviewslice(
     }
     if (new_memview) {
         __Pyx_BufFmt_Init(&ctx, stack, dtype);
-        if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
+        if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail;
     }
-    if ((unsigned) buf->itemsize != dtype->size) {
+    if (unlikely((unsigned) buf->itemsize != dtype->size)) {
         PyErr_Format(PyExc_ValueError,
                      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) "
                      "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)",
@@ -29879,15 +29277,17 @@ static int __Pyx_ValidateAndInit_memviewslice(
                      (dtype->size > 1) ? "s" : "");
         goto fail;
     }
-    for (i = 0; i < ndim; i++) {
-        spec = axes_specs[i];
-        if (!__pyx_check_strides(buf, i, ndim, spec))
-            goto fail;
-        if (!__pyx_check_suboffsets(buf, i, ndim, spec))
+    if (buf->len > 0) {
+        for (i = 0; i < ndim; i++) {
+            spec = axes_specs[i];
+            if (unlikely(!__pyx_check_strides(buf, i, ndim, spec)))
+                goto fail;
+            if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec)))
+                goto fail;
+        }
+        if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag)))
             goto fail;
     }
-    if (buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))
-        goto fail;
     if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice,
                                          new_memview != NULL) == -1)) {
         goto fail;
@@ -29903,7 +29303,7 @@ no_fail:
 }
 
 /* ObjectToMemviewSlice */
-  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(PyObject *obj, int writable_flag) {
+  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(PyObject *obj, int writable_flag) {
     __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
     __Pyx_BufFmt_StackElem stack[1];
     int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) };
@@ -29914,7 +29314,7 @@ no_fail:
     }
     retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG,
                                                  (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1,
-                                                 &__Pyx_TypeInfo___pyx_t_double_complex, stack,
+                                                 &__Pyx_TypeInfo_nn___pyx_t_9beam_calc_float_t, stack,
                                                  &result, obj);
     if (unlikely(retcode == -1))
         goto __pyx_fail;
@@ -29926,7 +29326,7 @@ __pyx_fail:
 }
 
 /* ObjectToMemviewSlice */
-  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_9beam_calc_float_t(PyObject *obj, int writable_flag) {
+  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc___pyx_t_double_complex(PyObject *obj, int writable_flag) {
     __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
     __Pyx_BufFmt_StackElem stack[1];
     int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) };
@@ -29937,7 +29337,7 @@ __pyx_fail:
     }
     retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG,
                                                  (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1,
-                                                 &__Pyx_TypeInfo_nn___pyx_t_9beam_calc_float_t, stack,
+                                                 &__Pyx_TypeInfo___pyx_t_double_complex, stack,
                                                  &result, obj);
     if (unlikely(retcode == -1))
         goto __pyx_fail;
@@ -30716,7 +30116,7 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
     struct __pyx_memoryview_obj *memview_obj = NULL;
     __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0);
     for (i = 0; i < ndim; i++) {
-        if (from_mvs->suboffsets[i] >= 0) {
+        if (unlikely(from_mvs->suboffsets[i] >= 0)) {
             PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with "
                                            "indirect dimensions (axis %d)", i);
             goto fail;
diff --git a/st_sim/bin/beam_calc.pyx b/st_sim/bin/beam_calc.pyx
index 488379b..b9d316e 100755
--- a/st_sim/bin/beam_calc.pyx
+++ b/st_sim/bin/beam_calc.pyx
@@ -7,64 +7,86 @@ cimport openmp
 
 ctypedef cnp.complex128_t complex_t
 ctypedef cnp.float64_t float_t
-ctypedef cnp.float32_t float32_t
 ctypedef cnp.int64_t int_t
 ctypedef cnp.uint64_t uint_t
 ctypedef cnp.uint8_t uint8_t
 DEF X_TOL = 4.320005384913445 # Y_TOL = 1e-9
 
+cdef float_t gsl_quad(gsl_function func, float_t a, float_t b, float_t eps_abs, float_t eps_rel, int_t limit) nogil:
+    cdef:
+        float_t result, error
+        gsl_integration_workspace * W
+    W = gsl_integration_workspace_alloc(limit)
+    gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)
+    gsl_integration_workspace_free(W)
+    return result
+
 cdef float_t lens_re(float_t xx, void* params) nogil:
     cdef:
         float_t x = (<float_t*> params)[0], wl = (<float_t*> params)[1]
         float_t f = (<float_t*> params)[2], df = (<float_t*> params)[3]
-        float_t a = (<float_t*> params)[4]
+        float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]
         float_t ph, ph_ab
     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx
-    ph_ab = -a * 1e9 * (xx / f)**3
+    ph_ab = -a * 1e9 * ((xx - x0) / f)**3
     return cos(ph + ph_ab)
 
 cdef float_t lens_im(float_t xx, void* params) nogil:
     cdef:
         float_t x = (<float_t*> params)[0], wl = (<float_t*> params)[1]
         float_t f = (<float_t*> params)[2], df = (<float_t*> params)[3]
-        float_t a = (<float_t*> params)[4]
+        float_t a = (<float_t*> params)[4], x0 = (<float_t*> params)[5]
         float_t ph, ph_ab
     ph = -pi * xx**2 / wl * df / f / (f + df) - 2 * pi / wl / (f + df) * x * xx
-    ph_ab = -a * 1e9 * (xx / f)**3
+    ph_ab = -a * 1e9 * ((xx - x0) / f)**3
     return sin(ph + ph_ab)
 
-cdef float_t aperture_re(float_t xx, void* params) nogil:
-    cdef:
-        float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
-    return cos(pi / wl / z * (x - xx)**2)
-
-cdef float_t aperture_im(float_t xx, void* params) nogil:
-    cdef:
-        float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
-    return sin(pi / wl / z * (x - xx)**2)
-
-cdef float_t gsl_quad(gsl_function func, float_t a, float_t b, float_t eps_abs, float_t eps_rel, int_t limit) nogil:
-    cdef:
-        float_t result, error
-        gsl_integration_workspace * W
-    W = gsl_integration_workspace_alloc(limit)
-    gsl_integration_qag(&func, a, b, eps_abs, eps_rel, limit, GSL_INTEG_GAUSS51, W, &result, &error)
-    gsl_integration_workspace_free(W)
-    return result
-
-cdef complex_t lens_wp(float_t x, float_t wl, float_t ap, float_t f, float_t df, float_t a) nogil:
+cdef complex_t lens_wp(float_t x, float_t wl, float_t ap, float_t f,
+                       float_t df, float_t a, float_t x0) nogil:
     cdef:
         float_t re, im, ph = pi / wl / (f + df) * x**2
-        float_t params[5]
+        float_t params[6]
         int_t fn = <int_t> (ap**2 / wl / (f + df))
         gsl_function func
     params[0] = x; params[1] = wl; params[2] = f
-    params[3] = df; params[4] = a
+    params[3] = df; params[4] = a; params[5] = x0
     func.function = &lens_re; func.params = params
     re = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
     func.function = &lens_im
     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
     return (re + 1j * im) * (cos(ph) + 1j * sin(ph))
+
+
+def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,
+         float_t defoc, float_t alpha, float_t x0):
+    """
+    Lens wavefront calculation by dint of Fresnel diffraction (without the coefficient)
+    with third order polinomial abberations
+
+    x_arr - coordinates at the plane downstream [um]
+    wl - wavelength [um]
+    ap - lens' size [um]
+    focus - focal distance [um]
+    defoc - defocus [um]
+    alpha - abberations coefficient [rad/mrad^3]
+    x0 - center point of the lens' abberations [um]
+    """
+    cdef:
+        int_t a = x_arr.shape[0], i
+        complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
+    for i in prange(a, schedule='guided', nogil=True, chunksize=10):
+        wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha, x0) 
+    return np.asarray(wave_arr)
+
+cdef float_t aperture_re(float_t xx, void* params) nogil:
+    cdef:
+        float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
+    return cos(pi / wl / z * (x - xx)**2)
+
+cdef float_t aperture_im(float_t xx, void* params) nogil:
+    cdef:
+        float_t x = (<float_t*> params)[0], z = (<float_t*> params)[1], wl = (<float_t*> params)[2]
+    return sin(pi / wl / z * (x - xx)**2)
     
 cdef complex_t aperture_wp(float_t x, float_t z, float_t wl, float_t ap) nogil:
     cdef:
@@ -79,6 +101,22 @@ cdef complex_t aperture_wp(float_t x, float_t z, float_t wl, float_t ap) nogil:
     im = gsl_quad(func, -ap / 2, ap / 2, 1e-9, 1e-7, 1000 * fn)
     return re + 1j * im
 
+def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):
+    """
+    Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)
+
+    x_arr - coordinates at the plane downstream [um]
+    z - propagation distance [um]
+    wl - wavelength [um]
+    ap - aperture's size [um]
+    """
+    cdef:
+        int_t a = x_arr.shape[0], i
+        complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
+    for i in prange(a, schedule='guided', nogil=True, chunksize=10):
+        wave_arr[i] = aperture_wp(x_arr[i], z, wl, ap)
+    return np.asarray(wave_arr)
+
 cdef complex_t fhf_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
     cdef:
         int_t a = wf0.shape[0], i
@@ -99,26 +137,6 @@ cdef void fhf_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, flo
     for i in range(a):
         wf1[i] = fhf_wp(wf0, x_arr, xx_arr[i], dist, wl)
 
-cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
-    cdef:
-        int_t a = wf0.shape[0], i
-        float_t ph0, ph1
-        complex_t wf
-    ph0 = pi / wl / dist * (x_arr[0] - xx)**2
-    ph1 = pi / wl / dist * (x_arr[1] - xx)**2
-    wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
-    for i in range(2, a):
-        ph0 = ph1
-        ph1 = pi / wl / dist * (x_arr[i] - xx)**2
-        wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
-    return wf
-
-cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
-    cdef:
-        int_t a = xx_arr.shape[0], i
-    for i in range(a):
-        wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
-
 def fraunhofer_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
     """
     1D Fraunhofer diffraction calculation (without the coefficient)
@@ -152,6 +170,26 @@ def fraunhofer_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr
         fhf_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
     return np.asarray(wf)
 
+cdef complex_t fnl_wp(complex_t[::1] wf0, float_t[::1] x_arr, float_t xx, float_t dist, float_t wl) nogil:
+    cdef:
+        int_t a = wf0.shape[0], i
+        float_t ph0, ph1
+        complex_t wf
+    ph0 = pi / wl / dist * (x_arr[0] - xx)**2
+    ph1 = pi / wl / dist * (x_arr[1] - xx)**2
+    wf = (wf0[0] * (cos(ph0) + 1j * sin(ph0)) + wf0[1] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[1] - x_arr[0])
+    for i in range(2, a):
+        ph0 = ph1
+        ph1 = pi / wl / dist * (x_arr[i] - xx)**2
+        wf += (wf0[i - 1] * (cos(ph0) + 1j * sin(ph0)) + wf0[i] * (cos(ph1) + 1j * sin(ph1))) / 2 * (x_arr[i] - x_arr[i - 1])
+    return wf
+
+cdef void fnl_1d(complex_t[::1] wf1, complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl) nogil:
+    cdef:
+        int_t a = xx_arr.shape[0], i
+    for i in range(a):
+        wf1[i] = fnl_wp(wf0, x_arr, xx_arr[i], dist, wl)
+
 def fresnel_1d(complex_t[::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, float_t dist, float_t wl):
     """
     1D Fresnel diffraction calculation (without the coefficient)
@@ -185,60 +223,23 @@ def fresnel_2d(complex_t[:, ::1] wf0, float_t[::1] x_arr, float_t[::1] xx_arr, f
         fnl_1d(wf[i], wf0[i], x_arr, xx_arr, dist, wl)
     return np.asarray(wf)
 
-def aperture(float_t[::1] x_arr, float_t z, float_t wl, float_t ap):
-    """
-    Aperture wavefront calculation by dint of Fresnel diffraction (without the coefficient)
-
-    x_arr - coordinates at the plane downstream [um]
-    z - propagation distance [um]
-    wl - wavelength [um]
-    ap - aperture's size [um]
-    """
-    cdef:
-        int_t a = x_arr.shape[0], i
-        complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
-    for i in prange(a, schedule='guided', nogil=True, chunksize=10):
-        wave_arr[i] = aperture_wp(x_arr[i], z, wl, ap)
-    return np.asarray(wave_arr)
-
-def lens(float_t[::1] x_arr, float_t wl, float_t ap, float_t focus,
-         float_t defoc, float_t alpha):
-    """
-    Lens wavefront calculation by dint of Fresnel diffraction (without the coefficient)
-    with third order polinomial abberations
-
-    x_arr - coordinates at the plane downstream [um]
-    wl - wavelength [um]
-    ap - lens' size [um]
-    focus - focal distance [um]
-    defoc - defocus [um]
-    alpha - abberations coefficient [rad/mrad^3]
-    """
-    cdef:
-        int_t a = x_arr.shape[0], i
-        complex_t[::1] wave_arr = np.empty((a,), dtype=np.complex128)
-    for i in prange(a, schedule='guided', nogil=True, chunksize=10):
-        wave_arr[i] = lens_wp(x_arr[i], wl, ap, focus, defoc, alpha) 
-    return np.asarray(wave_arr)
-
-def barcode_steps(float_t bm_dx, float_t br_dx, float_t rd, float_t ss, int_t nf):
+def barcode_steps(float_t x0, float_t x1, float_t br_dx, float_t rd):
     """
     Barcode bars' coordinates generation with random deviation
 
-    bm_dx - incident beam size [um]
+    x0, x1 - sample's bounds [um]
     br_dx - mean bar size [um]
     rd - random deviation (0.0 - 1.0)
-    ss - scan step size [um]
-    nf - number of frames of a scan
     """
     cdef:
-        int_t br_n = (<int_t>((bm_dx + ss * nf) / br_dx) // 2 + 1) * 2, i
+        int_t br_n = <int_t>((x1 - x0) / 2 / br_dx) * 2 if x1 - x0 > 0 else 0, i
         gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937)
-        float_t bs_min = max(1 - rd, 0), bs_max = 1 + rd
+        float_t bs_min = max(1 - rd, 0), bs_max = min(1 + rd, 2)
         float_t[::1] bx_arr = np.empty(br_n, dtype=np.float64)
-    bx_arr[0] = br_dx * (0.5 + bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
-    for i in range(1, br_n):
-        bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
+    if br_n:
+        bx_arr[0] = x0 + br_dx * ((bs_max - bs_min) * gsl_rng_uniform_pos(r) - 1)
+        for i in range(1, br_n):
+            bx_arr[i] = bx_arr[i - 1] + br_dx * (bs_min + (bs_max - bs_min) * gsl_rng_uniform_pos(r))
     return np.asarray(bx_arr)
 
 cdef int_t binary_search(float_t[::1] values, int_t l, int_t r, float_t x) nogil:
@@ -262,41 +263,61 @@ cdef int_t searchsorted(float_t[::1] values, float_t x) nogil:
     else:
         return binary_search(values, 0, r, x)
 
-cdef void barcode_1d(float_t[::1] br_tr, float_t[::1] x_arr, float_t[::1] bx_arr,
-                     float_t sgm, float_t atn, float_t step) nogil:
+cdef void barcode_c(float_t[::1] br_tr, float_t[::1] x_arr, float_t[::1] bx_arr,
+                     float_t sgm, float_t atn0, float_t atn, float_t step) nogil:
     cdef:
         int_t a = x_arr.shape[0], b = bx_arr.shape[0], i, j0, j
         float_t br_dx = (bx_arr[b - 1] - bx_arr[0]) / b
         int_t bb = <int_t>(X_TOL * sqrt(2) * sgm / br_dx + 1)
         float_t tr, xx, x0, x1
     for i in range(a):
-        xx = x_arr[i] - x_arr[0] + step
+        xx = x_arr[i] + step
         j0 = searchsorted(bx_arr, xx) # even '-', odd '+'
         tr = 0
         for j in range(j0 - bb, j0 + bb + 1):
             if j >= 1 and j < b:
                 x0 = (xx - bx_arr[j - 1]) / sqrt(2) / sgm
                 x1 = (xx - bx_arr[j]) / sqrt(2) / sgm
-                tr += 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))
-        br_tr[i] = sqrt(1 - atn / 2 + atn * tr)
+                tr += atn * 0.5 * (0.5 - j % 2) * (erf(x0) - erf(x1))
+        tr -= (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[0]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)
+        tr += (0.25 * atn + 0.5 * atn0) * erf((xx - bx_arr[b - 1]) / sqrt(2 + 2 * (atn0 / atn)**2) / sgm)
+        br_tr[i] = sqrt(1 + tr)
 
-def barcode(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn, float_t ss, int_t nf):
+def barcode_1d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm, float_t atn0, float_t atn):
+    """
+    Barcode transmission array for a scan
+
+    x_arr - coordinates [um]
+    bx_arr - bar coordinates array [um]
+    sgm - bar haziness width [um]
+    atn0, atn - bulk and bar attenuation (0.0 - 1.0)
+    ss - scan step size [um]
+    nf - number of frames of a scan
+    """
+    cdef:
+        int_t a = x_arr.shape[0]
+        float_t[::1] br_tr = np.empty(a, dtype=np.float64)
+    barcode_c(br_tr, x_arr, bx_arr, sgm, atn0, atn, 0)
+    return np.asarray(br_tr)
+        
+def barcode_2d(float_t[::1] x_arr, float_t[::1] bx_arr, float_t sgm,
+               float_t atn0, float_t atn, float_t ss, int_t nf):
     """
     Barcode transmission array for a scan
 
     x_arr - coordinates [um]
     bx_arr - bar coordinates array [um]
     sgm - bar haziness width [um]
-    atn - bar attenuation (0.0 - 1.0)
+    atn0, atn - bulk and bar attenuation (0.0 - 1.0)
     ss - scan step size [um]
     nf - number of frames of a scan
     """
     cdef:
         int_t a = x_arr.shape[0], i
-        float_t[:, ::1] bc_t = np.empty((nf, a), dtype=np.float64)
+        float_t[:, ::1] br_tr = np.empty((nf, a), dtype=np.float64)
     for i in prange(nf, schedule='guided', nogil=True):
-        barcode_1d(bc_t[i], x_arr, bx_arr, sgm, atn, i * ss)
-    return np.asarray(bc_t)
+        barcode_c(br_tr[i], x_arr, bx_arr, sgm, atn0, atn, i * ss)
+    return np.asarray(br_tr)
 
 cdef float_t convolve_c(float_t[::1] a1, float_t[::1] a2, int_t k) nogil:
     cdef:
diff --git a/st_sim/bin/st_utils.c b/st_sim/bin/st_utils.c
index 6f594ec..a90aeec 100644
--- a/st_sim/bin/st_utils.c
+++ b/st_sim/bin/st_utils.c
@@ -1279,31 +1279,22 @@ typedef int __pyx_t_10cython_gsl_size_t;
  * 
  * ctypedef cnp.complex128_t complex_t
  * ctypedef cnp.float64_t float_t             # <<<<<<<<<<<<<<
- * ctypedef cnp.float32_t float32_t
  * ctypedef cnp.int64_t int_t
+ * ctypedef cnp.uint64_t uint_t
  */
 typedef __pyx_t_5numpy_float64_t __pyx_t_8st_utils_float_t;
 
 /* "st_utils.pyx":10
  * ctypedef cnp.complex128_t complex_t
  * ctypedef cnp.float64_t float_t
- * ctypedef cnp.float32_t float32_t             # <<<<<<<<<<<<<<
- * ctypedef cnp.int64_t int_t
- * ctypedef cnp.uint64_t uint_t
- */
-typedef __pyx_t_5numpy_float32_t __pyx_t_8st_utils_float32_t;
-
-/* "st_utils.pyx":11
- * ctypedef cnp.float64_t float_t
- * ctypedef cnp.float32_t float32_t
  * ctypedef cnp.int64_t int_t             # <<<<<<<<<<<<<<
  * ctypedef cnp.uint64_t uint_t
  * ctypedef cnp.uint8_t uint8_t
  */
 typedef __pyx_t_5numpy_int64_t __pyx_t_8st_utils_int_t;
 
-/* "st_utils.pyx":12
- * ctypedef cnp.float32_t float32_t
+/* "st_utils.pyx":11
+ * ctypedef cnp.float64_t float_t
  * ctypedef cnp.int64_t int_t
  * ctypedef cnp.uint64_t uint_t             # <<<<<<<<<<<<<<
  * ctypedef cnp.uint8_t uint8_t
@@ -1311,7 +1302,7 @@ typedef __pyx_t_5numpy_int64_t __pyx_t_8st_utils_int_t;
  */
 typedef __pyx_t_5numpy_uint64_t __pyx_t_8st_utils_uint_t;
 
-/* "st_utils.pyx":13
+/* "st_utils.pyx":12
  * ctypedef cnp.int64_t int_t
  * ctypedef cnp.uint64_t uint_t
  * ctypedef cnp.uint8_t uint8_t             # <<<<<<<<<<<<<<
@@ -1320,7 +1311,7 @@ typedef __pyx_t_5numpy_uint64_t __pyx_t_8st_utils_uint_t;
  */
 typedef __pyx_t_5numpy_uint8_t __pyx_t_8st_utils_uint8_t;
 
-/* "st_utils.pyx":14
+/* "st_utils.pyx":13
  * ctypedef cnp.uint64_t uint_t
  * ctypedef cnp.uint8_t uint8_t
  * ctypedef cnp.npy_bool bool_t             # <<<<<<<<<<<<<<
@@ -2211,14 +2202,11 @@ static int __Pyx_ValidateAndInit_memviewslice(
                 PyObject *original_obj);
 
 /* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float32_t(PyObject *, int writable_flag);
+static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(PyObject *, int writable_flag);
 
 /* ObjectToMemviewSlice.proto */
 static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_bool_t(PyObject *, int writable_flag);
 
-/* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(PyObject *, int writable_flag);
-
 /* ObjectToMemviewSlice.proto */
 static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(PyObject *, int writable_flag);
 
@@ -2231,10 +2219,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_uint64(npy_uint64 value);
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_int64(npy_int64 value);
 
-/* MemviewDtypeToObject.proto */
-static CYTHON_INLINE PyObject *__pyx_memview_get_nn___pyx_t_8st_utils_float32_t(const char *itemp);
-static CYTHON_INLINE int __pyx_memview_set_nn___pyx_t_8st_utils_float32_t(const char *itemp, PyObject *obj);
-
 /* MemviewDtypeToObject.proto */
 static CYTHON_INLINE PyObject *__pyx_memview_get_nn___pyx_t_8st_utils_float_t(const char *itemp);
 static CYTHON_INLINE int __pyx_memview_set_nn___pyx_t_8st_utils_float_t(const char *itemp, PyObject *obj);
@@ -2368,9 +2352,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 /* CIntFromPy.proto */
 static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *);
 
-/* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float32_t(PyObject *, int writable_flag);
-
 /* CheckBinaryVersion.proto */
 static int __Pyx_check_binary_version(void);
 
@@ -2573,7 +2554,7 @@ static PyObject *contiguous = 0;
 static PyObject *indirect_contiguous = 0;
 static int __pyx_memoryview_thread_locks_used;
 static PyThread_type_lock __pyx_memoryview_thread_locks[8];
-static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_memviewslice, int); /*proto*/
+static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_wirthselect_float(__Pyx_memviewslice, int); /*proto*/
 static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_min_float(__pyx_t_8st_utils_float_t *, __pyx_t_8st_utils_int_t); /*proto*/
 static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_float_t *, __pyx_t_8st_utils_int_t); /*proto*/
 static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_rbf(__pyx_t_8st_utils_float_t, __pyx_t_8st_utils_float_t); /*proto*/
@@ -2613,9 +2594,8 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_
 static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/
 static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/
 static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/
-static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_8st_utils_float32_t = { "float32_t", NULL, sizeof(__pyx_t_8st_utils_float32_t), { 0 }, 0, 'R', 0, 0 };
-static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_8st_utils_bool_t = { "bool_t", NULL, sizeof(__pyx_t_8st_utils_bool_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_8st_utils_bool_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_8st_utils_bool_t), 0 };
 static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_8st_utils_float_t = { "float_t", NULL, sizeof(__pyx_t_8st_utils_float_t), { 0 }, 0, 'R', 0, 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_8st_utils_bool_t = { "bool_t", NULL, sizeof(__pyx_t_8st_utils_bool_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_8st_utils_bool_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_8st_utils_bool_t), 0 };
 #define __Pyx_MODULE_NAME "st_utils"
 extern int __pyx_module_is_main_st_utils;
 int __pyx_module_is_main_st_utils = 0;
@@ -2704,7 +2684,6 @@ static const char __pyx_k_struct[] = "struct";
 static const char __pyx_k_unpack[] = "unpack";
 static const char __pyx_k_update[] = "update";
 static const char __pyx_k_asarray[] = "asarray";
-static const char __pyx_k_float32[] = "float32";
 static const char __pyx_k_float64[] = "float64";
 static const char __pyx_k_fortran[] = "fortran";
 static const char __pyx_k_memview[] = "memview";
@@ -2739,6 +2718,7 @@ static const char __pyx_k_allocate_buffer[] = "allocate_buffer";
 static const char __pyx_k_dtype_is_object[] = "dtype_is_object";
 static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_update_pixel_map[] = "update_pixel_map";
 static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
 static const char __pyx_k_make_whitefield_st[] = "make_whitefield_st";
@@ -2748,7 +2728,6 @@ static const char __pyx_k_contiguous_and_direct[] = "<contiguous and direct>";
 static const char __pyx_k_MemoryView_of_r_object[] = "<MemoryView of %r object>";
 static const char __pyx_k_MemoryView_of_r_at_0x_x[] = "<MemoryView of %r at 0x%x>";
 static const char __pyx_k_contiguous_and_indirect[] = "<contiguous and indirect>";
-static const char __pyx_k_update_pixel_map_search[] = "update_pixel_map_search";
 static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'";
 static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d.";
 static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array";
@@ -2838,7 +2817,6 @@ static PyObject *__pyx_n_s_enumerate;
 static PyObject *__pyx_n_s_err;
 static PyObject *__pyx_n_s_error;
 static PyObject *__pyx_n_s_flags;
-static PyObject *__pyx_n_s_float32;
 static PyObject *__pyx_n_s_float64;
 static PyObject *__pyx_n_s_format;
 static PyObject *__pyx_n_s_fortran;
@@ -2915,7 +2893,7 @@ static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str;
 static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
 static PyObject *__pyx_n_s_unpack;
 static PyObject *__pyx_n_s_update;
-static PyObject *__pyx_n_s_update_pixel_map_search;
+static PyObject *__pyx_n_s_update_pixel_map;
 static PyObject *__pyx_n_s_w0;
 static PyObject *__pyx_n_s_wf;
 static PyObject *__pyx_n_s_wfs;
@@ -2923,7 +2901,7 @@ static PyObject *__pyx_n_s_wss;
 static PyObject *__pyx_n_s_zeros;
 static PyObject *__pyx_pf_8st_utils_make_whitefield_st(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_data, __Pyx_memviewslice __pyx_v_mask); /* proto */
 static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_I_n, __Pyx_memviewslice __pyx_v_W, __Pyx_memviewslice __pyx_v_u, __Pyx_memviewslice __pyx_v_di, __Pyx_memviewslice __pyx_v_dj, __pyx_t_8st_utils_float_t __pyx_v_ls); /* proto */
-static PyObject *__pyx_pf_8st_utils_4update_pixel_map_search(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_I_n, __Pyx_memviewslice __pyx_v_W, __Pyx_memviewslice __pyx_v_I0, __Pyx_memviewslice __pyx_v_u0, __Pyx_memviewslice __pyx_v_di, __Pyx_memviewslice __pyx_v_dj, __pyx_t_8st_utils_float_t __pyx_v_dss, __pyx_t_8st_utils_float_t __pyx_v_dfs, __pyx_t_8st_utils_uint_t __pyx_v_wss, __pyx_t_8st_utils_uint_t __pyx_v_wfs); /* proto */
+static PyObject *__pyx_pf_8st_utils_4update_pixel_map(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_I_n, __Pyx_memviewslice __pyx_v_W, __Pyx_memviewslice __pyx_v_I0, __Pyx_memviewslice __pyx_v_u0, __Pyx_memviewslice __pyx_v_di, __Pyx_memviewslice __pyx_v_dj, __pyx_t_8st_utils_float_t __pyx_v_dss, __pyx_t_8st_utils_float_t __pyx_v_dfs, __pyx_t_8st_utils_uint_t __pyx_v_wss, __pyx_t_8st_utils_uint_t __pyx_v_wfs); /* proto */
 static PyObject *__pyx_pf_8st_utils_6total_mse(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_I_n, __Pyx_memviewslice __pyx_v_W, __Pyx_memviewslice __pyx_v_I0, __Pyx_memviewslice __pyx_v_u, __Pyx_memviewslice __pyx_v_di, __Pyx_memviewslice __pyx_v_dj); /* proto */
 static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
 static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
@@ -3020,22 +2998,22 @@ static PyObject *__pyx_codeobj__33;
 static PyObject *__pyx_codeobj__40;
 /* Late includes */
 
-/* "st_utils.pyx":17
+/* "st_utils.pyx":16
  * DEF FLOAT_MAX = 1.7976931348623157e+308
  * 
- * cdef float32_t wirthselect_float(float32_t[:] array, int k) nogil:             # <<<<<<<<<<<<<<
+ * cdef float_t wirthselect_float(float_t[:] array, int k) nogil:             # <<<<<<<<<<<<<<
  *     cdef:
  *         int_t l = 0, m = array.shape[0] - 1, i, j
  */
 
-static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_memviewslice __pyx_v_array, int __pyx_v_k) {
+static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_wirthselect_float(__Pyx_memviewslice __pyx_v_array, int __pyx_v_k) {
   __pyx_t_8st_utils_int_t __pyx_v_l;
   __pyx_t_8st_utils_int_t __pyx_v_m;
   __pyx_t_8st_utils_int_t __pyx_v_i;
   __pyx_t_8st_utils_int_t __pyx_v_j;
-  __pyx_t_8st_utils_float32_t __pyx_v_x;
-  __pyx_t_8st_utils_float32_t __pyx_v_tmp;
-  __pyx_t_8st_utils_float32_t __pyx_r;
+  __pyx_t_8st_utils_float_t __pyx_v_x;
+  __pyx_t_8st_utils_float_t __pyx_v_tmp;
+  __pyx_t_8st_utils_float_t __pyx_r;
   int __pyx_t_1;
   Py_ssize_t __pyx_t_2;
   __pyx_t_8st_utils_int_t __pyx_t_3;
@@ -3046,19 +3024,19 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
   __pyx_t_8st_utils_int_t __pyx_t_8;
   Py_ssize_t __pyx_t_9;
 
-  /* "st_utils.pyx":19
- * cdef float32_t wirthselect_float(float32_t[:] array, int k) nogil:
+  /* "st_utils.pyx":18
+ * cdef float_t wirthselect_float(float_t[:] array, int k) nogil:
  *     cdef:
  *         int_t l = 0, m = array.shape[0] - 1, i, j             # <<<<<<<<<<<<<<
- *         float32_t x, tmp
+ *         float_t x, tmp
  *     while l < m:
  */
   __pyx_v_l = 0;
   __pyx_v_m = ((__pyx_v_array.shape[0]) - 1);
 
-  /* "st_utils.pyx":21
+  /* "st_utils.pyx":20
  *         int_t l = 0, m = array.shape[0] - 1, i, j
- *         float32_t x, tmp
+ *         float_t x, tmp
  *     while l < m:             # <<<<<<<<<<<<<<
  *         x = array[k]
  *         i = l; j = m
@@ -3067,17 +3045,17 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
     __pyx_t_1 = ((__pyx_v_l < __pyx_v_m) != 0);
     if (!__pyx_t_1) break;
 
-    /* "st_utils.pyx":22
- *         float32_t x, tmp
+    /* "st_utils.pyx":21
+ *         float_t x, tmp
  *     while l < m:
  *         x = array[k]             # <<<<<<<<<<<<<<
  *         i = l; j = m
  *         while 1:
  */
     __pyx_t_2 = __pyx_v_k;
-    __pyx_v_x = (*((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_2 * __pyx_v_array.strides[0]) )));
+    __pyx_v_x = (*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_2 * __pyx_v_array.strides[0]) )));
 
-    /* "st_utils.pyx":23
+    /* "st_utils.pyx":22
  *     while l < m:
  *         x = array[k]
  *         i = l; j = m             # <<<<<<<<<<<<<<
@@ -3087,7 +3065,7 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
     __pyx_v_i = __pyx_v_l;
     __pyx_v_j = __pyx_v_m;
 
-    /* "st_utils.pyx":24
+    /* "st_utils.pyx":23
  *         x = array[k]
  *         i = l; j = m
  *         while 1:             # <<<<<<<<<<<<<<
@@ -3096,7 +3074,7 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
  */
     while (1) {
 
-      /* "st_utils.pyx":25
+      /* "st_utils.pyx":24
  *         i = l; j = m
  *         while 1:
  *             while array[i] < x: i += 1             # <<<<<<<<<<<<<<
@@ -3105,12 +3083,12 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
  */
       while (1) {
         __pyx_t_3 = __pyx_v_i;
-        __pyx_t_1 = (((*((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_3 * __pyx_v_array.strides[0]) ))) < __pyx_v_x) != 0);
+        __pyx_t_1 = (((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_3 * __pyx_v_array.strides[0]) ))) < __pyx_v_x) != 0);
         if (!__pyx_t_1) break;
         __pyx_v_i = (__pyx_v_i + 1);
       }
 
-      /* "st_utils.pyx":26
+      /* "st_utils.pyx":25
  *         while 1:
  *             while array[i] < x: i += 1
  *             while x < array[j]: j -= 1             # <<<<<<<<<<<<<<
@@ -3119,12 +3097,12 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
  */
       while (1) {
         __pyx_t_4 = __pyx_v_j;
-        __pyx_t_1 = ((__pyx_v_x < (*((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_4 * __pyx_v_array.strides[0]) )))) != 0);
+        __pyx_t_1 = ((__pyx_v_x < (*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_4 * __pyx_v_array.strides[0]) )))) != 0);
         if (!__pyx_t_1) break;
         __pyx_v_j = (__pyx_v_j - 1);
       }
 
-      /* "st_utils.pyx":27
+      /* "st_utils.pyx":26
  *             while array[i] < x: i += 1
  *             while x < array[j]: j -= 1
  *             if i <= j:             # <<<<<<<<<<<<<<
@@ -3134,7 +3112,7 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
       __pyx_t_1 = ((__pyx_v_i <= __pyx_v_j) != 0);
       if (__pyx_t_1) {
 
-        /* "st_utils.pyx":28
+        /* "st_utils.pyx":27
  *             while x < array[j]: j -= 1
  *             if i <= j:
  *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp             # <<<<<<<<<<<<<<
@@ -3142,14 +3120,14 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
  *             if i > j: break
  */
         __pyx_t_5 = __pyx_v_i;
-        __pyx_v_tmp = (*((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_5 * __pyx_v_array.strides[0]) )));
+        __pyx_v_tmp = (*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_5 * __pyx_v_array.strides[0]) )));
         __pyx_t_6 = __pyx_v_j;
         __pyx_t_7 = __pyx_v_i;
-        *((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_7 * __pyx_v_array.strides[0]) )) = (*((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_6 * __pyx_v_array.strides[0]) )));
+        *((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_7 * __pyx_v_array.strides[0]) )) = (*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_6 * __pyx_v_array.strides[0]) )));
         __pyx_t_8 = __pyx_v_j;
-        *((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_8 * __pyx_v_array.strides[0]) )) = __pyx_v_tmp;
+        *((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_8 * __pyx_v_array.strides[0]) )) = __pyx_v_tmp;
 
-        /* "st_utils.pyx":29
+        /* "st_utils.pyx":28
  *             if i <= j:
  *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
  *                 i += 1; j -= 1             # <<<<<<<<<<<<<<
@@ -3159,7 +3137,7 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
         __pyx_v_i = (__pyx_v_i + 1);
         __pyx_v_j = (__pyx_v_j - 1);
 
-        /* "st_utils.pyx":27
+        /* "st_utils.pyx":26
  *             while array[i] < x: i += 1
  *             while x < array[j]: j -= 1
  *             if i <= j:             # <<<<<<<<<<<<<<
@@ -3168,7 +3146,7 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
  */
       }
 
-      /* "st_utils.pyx":30
+      /* "st_utils.pyx":29
  *                 tmp = array[i]; array[i] = array[j]; array[j] = tmp
  *                 i += 1; j -= 1
  *             if i > j: break             # <<<<<<<<<<<<<<
@@ -3182,7 +3160,7 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
     }
     __pyx_L6_break:;
 
-    /* "st_utils.pyx":31
+    /* "st_utils.pyx":30
  *                 i += 1; j -= 1
  *             if i > j: break
  *         if j < k: l = i             # <<<<<<<<<<<<<<
@@ -3194,7 +3172,7 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
       __pyx_v_l = __pyx_v_i;
     }
 
-    /* "st_utils.pyx":32
+    /* "st_utils.pyx":31
  *             if i > j: break
  *         if j < k: l = i
  *         if k < i: m = j             # <<<<<<<<<<<<<<
@@ -3207,21 +3185,21 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
     }
   }
 
-  /* "st_utils.pyx":33
+  /* "st_utils.pyx":32
  *         if j < k: l = i
  *         if k < i: m = j
  *     return array[k]             # <<<<<<<<<<<<<<
  * 
- * def make_whitefield_st(float32_t[:, :, ::1] data, bool_t[:, ::1] mask):
+ * def make_whitefield_st(float_t[:, :, ::1] data, bool_t[:, ::1] mask):
  */
   __pyx_t_9 = __pyx_v_k;
-  __pyx_r = (*((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_9 * __pyx_v_array.strides[0]) )));
+  __pyx_r = (*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_array.data + __pyx_t_9 * __pyx_v_array.strides[0]) )));
   goto __pyx_L0;
 
-  /* "st_utils.pyx":17
+  /* "st_utils.pyx":16
  * DEF FLOAT_MAX = 1.7976931348623157e+308
  * 
- * cdef float32_t wirthselect_float(float32_t[:] array, int k) nogil:             # <<<<<<<<<<<<<<
+ * cdef float_t wirthselect_float(float_t[:] array, int k) nogil:             # <<<<<<<<<<<<<<
  *     cdef:
  *         int_t l = 0, m = array.shape[0] - 1, i, j
  */
@@ -3231,10 +3209,10 @@ static __pyx_t_8st_utils_float32_t __pyx_f_8st_utils_wirthselect_float(__Pyx_mem
   return __pyx_r;
 }
 
-/* "st_utils.pyx":35
+/* "st_utils.pyx":34
  *     return array[k]
  * 
- * def make_whitefield_st(float32_t[:, :, ::1] data, bool_t[:, ::1] mask):             # <<<<<<<<<<<<<<
+ * def make_whitefield_st(float_t[:, :, ::1] data, bool_t[:, ::1] mask):             # <<<<<<<<<<<<<<
  *     """
  *     Return whitefield based on median filtering of the stack of frames
  */
@@ -3272,11 +3250,11 @@ static PyObject *__pyx_pw_8st_utils_1make_whitefield_st(PyObject *__pyx_self, Py
         case  1:
         if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_whitefield_st", 1, 2, 2, 1); __PYX_ERR(0, 35, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("make_whitefield_st", 1, 2, 2, 1); __PYX_ERR(0, 34, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_whitefield_st") < 0)) __PYX_ERR(0, 35, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_whitefield_st") < 0)) __PYX_ERR(0, 34, __pyx_L3_error)
       }
     } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
       goto __pyx_L5_argtuple_error;
@@ -3284,12 +3262,12 @@ static PyObject *__pyx_pw_8st_utils_1make_whitefield_st(PyObject *__pyx_self, Py
       values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
       values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
     }
-    __pyx_v_data = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float32_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_data.memview)) __PYX_ERR(0, 35, __pyx_L3_error)
-    __pyx_v_mask = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_bool_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_mask.memview)) __PYX_ERR(0, 35, __pyx_L3_error)
+    __pyx_v_data = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_data.memview)) __PYX_ERR(0, 34, __pyx_L3_error)
+    __pyx_v_mask = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_bool_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_mask.memview)) __PYX_ERR(0, 34, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("make_whitefield_st", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 35, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("make_whitefield_st", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 34, __pyx_L3_error)
   __pyx_L3_error:;
   __Pyx_AddTraceback("st_utils.make_whitefield_st", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
@@ -3338,43 +3316,43 @@ static PyObject *__pyx_pf_8st_utils_make_whitefield_st(CYTHON_UNUSED PyObject *_
   __pyx_t_8st_utils_int_t __pyx_t_22;
   __Pyx_RefNannySetupContext("make_whitefield_st", 0);
 
-  /* "st_utils.pyx":43
+  /* "st_utils.pyx":42
  *     """
  *     cdef:
  *         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k             # <<<<<<<<<<<<<<
  *         int_t max_threads = openmp.omp_get_max_threads()
- *         float32_t[:, ::1] wf = np.empty((b, c), dtype=np.float32)
+ *         float_t[:, ::1] wf = np.empty((b, c), dtype=np.float64)
  */
   __pyx_v_a = (__pyx_v_data.shape[0]);
   __pyx_v_b = (__pyx_v_data.shape[1]);
   __pyx_v_c = (__pyx_v_data.shape[2]);
 
-  /* "st_utils.pyx":44
+  /* "st_utils.pyx":43
  *     cdef:
  *         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k
  *         int_t max_threads = openmp.omp_get_max_threads()             # <<<<<<<<<<<<<<
- *         float32_t[:, ::1] wf = np.empty((b, c), dtype=np.float32)
- *         float32_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float32)
+ *         float_t[:, ::1] wf = np.empty((b, c), dtype=np.float64)
+ *         float_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float64)
  */
   __pyx_v_max_threads = omp_get_max_threads();
 
-  /* "st_utils.pyx":45
+  /* "st_utils.pyx":44
  *         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k
  *         int_t max_threads = openmp.omp_get_max_threads()
- *         float32_t[:, ::1] wf = np.empty((b, c), dtype=np.float32)             # <<<<<<<<<<<<<<
- *         float32_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float32)
+ *         float_t[:, ::1] wf = np.empty((b, c), dtype=np.float64)             # <<<<<<<<<<<<<<
+ *         float_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float64)
  *     for j in prange(b, schedule='guided', nogil=True):
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_c); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_c); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_GIVEREF(__pyx_t_1);
   PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
@@ -3382,48 +3360,48 @@ static PyObject *__pyx_pf_8st_utils_make_whitefield_st(CYTHON_UNUSED PyObject *_
   PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
   __pyx_t_1 = 0;
   __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_4);
   PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
   __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 45, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float32_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(__pyx_t_5, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 44, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_v_wf = __pyx_t_6;
   __pyx_t_6.memview = NULL;
   __pyx_t_6.data = NULL;
 
-  /* "st_utils.pyx":46
+  /* "st_utils.pyx":45
  *         int_t max_threads = openmp.omp_get_max_threads()
- *         float32_t[:, ::1] wf = np.empty((b, c), dtype=np.float32)
- *         float32_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         float_t[:, ::1] wf = np.empty((b, c), dtype=np.float64)
+ *         float_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float64)             # <<<<<<<<<<<<<<
  *     for j in prange(b, schedule='guided', nogil=True):
  *         i = openmp.omp_get_thread_num()
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyInt_From_npy_int64(__pyx_v_max_threads); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyInt_From_npy_int64(__pyx_v_max_threads); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_GIVEREF(__pyx_t_5);
   PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
@@ -3431,34 +3409,34 @@ static PyObject *__pyx_pf_8st_utils_make_whitefield_st(CYTHON_UNUSED PyObject *_
   PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
   __pyx_t_5 = 0;
   __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_2);
   PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
   __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float32_t(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 45, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_array = __pyx_t_6;
   __pyx_t_6.memview = NULL;
   __pyx_t_6.data = NULL;
 
-  /* "st_utils.pyx":47
- *         float32_t[:, ::1] wf = np.empty((b, c), dtype=np.float32)
- *         float32_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float32)
+  /* "st_utils.pyx":46
+ *         float_t[:, ::1] wf = np.empty((b, c), dtype=np.float64)
+ *         float_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float64)
  *     for j in prange(b, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
  *         i = openmp.omp_get_thread_num()
  *         for k in range(c):
@@ -3510,8 +3488,8 @@ static PyObject *__pyx_pf_8st_utils_make_whitefield_st(CYTHON_UNUSED PyObject *_
                             __pyx_v_i = ((__pyx_t_8st_utils_int_t)0xbad0bad0);
                             __pyx_v_k = ((__pyx_t_8st_utils_int_t)0xbad0bad0);
 
-                            /* "st_utils.pyx":48
- *         float32_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float32)
+                            /* "st_utils.pyx":47
+ *         float_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float64)
  *     for j in prange(b, schedule='guided', nogil=True):
  *         i = openmp.omp_get_thread_num()             # <<<<<<<<<<<<<<
  *         for k in range(c):
@@ -3519,7 +3497,7 @@ static PyObject *__pyx_pf_8st_utils_make_whitefield_st(CYTHON_UNUSED PyObject *_
  */
                             __pyx_v_i = omp_get_thread_num();
 
-                            /* "st_utils.pyx":49
+                            /* "st_utils.pyx":48
  *     for j in prange(b, schedule='guided', nogil=True):
  *         i = openmp.omp_get_thread_num()
  *         for k in range(c):             # <<<<<<<<<<<<<<
@@ -3531,7 +3509,7 @@ static PyObject *__pyx_pf_8st_utils_make_whitefield_st(CYTHON_UNUSED PyObject *_
                             for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
                               __pyx_v_k = __pyx_t_12;
 
-                              /* "st_utils.pyx":50
+                              /* "st_utils.pyx":49
  *         i = openmp.omp_get_thread_num()
  *         for k in range(c):
  *             if mask[j, k]:             # <<<<<<<<<<<<<<
@@ -3543,7 +3521,7 @@ static PyObject *__pyx_pf_8st_utils_make_whitefield_st(CYTHON_UNUSED PyObject *_
                               __pyx_t_15 = ((*((__pyx_t_8st_utils_bool_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_bool_t *) ( /* dim=0 */ (__pyx_v_mask.data + __pyx_t_13 * __pyx_v_mask.strides[0]) )) + __pyx_t_14)) ))) != 0);
                               if (__pyx_t_15) {
 
-                                /* "st_utils.pyx":51
+                                /* "st_utils.pyx":50
  *         for k in range(c):
  *             if mask[j, k]:
  *                 array[i] = data[:, j, k]             # <<<<<<<<<<<<<<
@@ -3560,14 +3538,14 @@ __pyx_t_16.strides[0] = __pyx_v_data.strides[0];
 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_j;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_data.strides[1];
-        if ((0)) __PYX_ERR(0, 51, __pyx_L8_error)
+        if ((0)) __PYX_ERR(0, 50, __pyx_L8_error)
         __pyx_t_16.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_k;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_data.strides[2];
-        if ((0)) __PYX_ERR(0, 51, __pyx_L8_error)
+        if ((0)) __PYX_ERR(0, 50, __pyx_L8_error)
         __pyx_t_16.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
@@ -3577,7 +3555,7 @@ __pyx_t_17.data = __pyx_v_array.data;
                                 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_array.strides[0];
-        if ((0)) __PYX_ERR(0, 51, __pyx_L8_error)
+        if ((0)) __PYX_ERR(0, 50, __pyx_L8_error)
         __pyx_t_17.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
@@ -3585,7 +3563,7 @@ __pyx_t_17.shape[0] = __pyx_v_array.shape[1];
 __pyx_t_17.strides[0] = __pyx_v_array.strides[1];
     __pyx_t_17.suboffsets[0] = -1;
 
-if (unlikely(__pyx_memoryview_copy_contents(__pyx_t_16, __pyx_t_17, 1, 1, 0) < 0)) __PYX_ERR(0, 51, __pyx_L8_error)
+if (unlikely(__pyx_memoryview_copy_contents(__pyx_t_16, __pyx_t_17, 1, 1, 0) < 0)) __PYX_ERR(0, 50, __pyx_L8_error)
                                 __PYX_XDEC_MEMVIEW(&__pyx_t_17, 0);
                                 __pyx_t_17.memview = NULL;
                                 __pyx_t_17.data = NULL;
@@ -3593,7 +3571,7 @@ if (unlikely(__pyx_memoryview_copy_contents(__pyx_t_16, __pyx_t_17, 1, 1, 0) < 0
                                 __pyx_t_16.memview = NULL;
                                 __pyx_t_16.data = NULL;
 
-                                /* "st_utils.pyx":52
+                                /* "st_utils.pyx":51
  *             if mask[j, k]:
  *                 array[i] = data[:, j, k]
  *                 wf[j, k] = wirthselect_float(array[i], a // 2)             # <<<<<<<<<<<<<<
@@ -3606,7 +3584,7 @@ if (unlikely(__pyx_memoryview_copy_contents(__pyx_t_16, __pyx_t_17, 1, 1, 0) < 0
                                 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_array.strides[0];
-        if ((0)) __PYX_ERR(0, 52, __pyx_L8_error)
+        if ((0)) __PYX_ERR(0, 51, __pyx_L8_error)
         __pyx_t_18.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
@@ -3616,12 +3594,12 @@ __pyx_t_18.strides[0] = __pyx_v_array.strides[1];
 
 __pyx_t_19 = __pyx_v_j;
                                 __pyx_t_20 = __pyx_v_k;
-                                *((__pyx_t_8st_utils_float32_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_wf.data + __pyx_t_19 * __pyx_v_wf.strides[0]) )) + __pyx_t_20)) )) = __pyx_f_8st_utils_wirthselect_float(__pyx_t_18, (__pyx_v_a / 2));
+                                *((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_wf.data + __pyx_t_19 * __pyx_v_wf.strides[0]) )) + __pyx_t_20)) )) = __pyx_f_8st_utils_wirthselect_float(__pyx_t_18, (__pyx_v_a / 2));
                                 __PYX_XDEC_MEMVIEW(&__pyx_t_18, 0);
                                 __pyx_t_18.memview = NULL;
                                 __pyx_t_18.data = NULL;
 
-                                /* "st_utils.pyx":50
+                                /* "st_utils.pyx":49
  *         i = openmp.omp_get_thread_num()
  *         for k in range(c):
  *             if mask[j, k]:             # <<<<<<<<<<<<<<
@@ -3631,7 +3609,7 @@ __pyx_t_19 = __pyx_v_j;
                                 goto __pyx_L12;
                               }
 
-                              /* "st_utils.pyx":54
+                              /* "st_utils.pyx":53
  *                 wf[j, k] = wirthselect_float(array[i], a // 2)
  *             else:
  *                 wf[j, k] = 0             # <<<<<<<<<<<<<<
@@ -3641,7 +3619,7 @@ __pyx_t_19 = __pyx_v_j;
                               /*else*/ {
                                 __pyx_t_21 = __pyx_v_j;
                                 __pyx_t_22 = __pyx_v_k;
-                                *((__pyx_t_8st_utils_float32_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float32_t *) ( /* dim=0 */ (__pyx_v_wf.data + __pyx_t_21 * __pyx_v_wf.strides[0]) )) + __pyx_t_22)) )) = 0.0;
+                                *((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_wf.data + __pyx_t_21 * __pyx_v_wf.strides[0]) )) + __pyx_t_22)) )) = 0.0;
                               }
                               __pyx_L12:;
                             }
@@ -3733,9 +3711,9 @@ __pyx_t_19 = __pyx_v_j;
         #endif
       }
 
-      /* "st_utils.pyx":47
- *         float32_t[:, ::1] wf = np.empty((b, c), dtype=np.float32)
- *         float32_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float32)
+      /* "st_utils.pyx":46
+ *         float_t[:, ::1] wf = np.empty((b, c), dtype=np.float64)
+ *         float_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float64)
  *     for j in prange(b, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
  *         i = openmp.omp_get_thread_num()
  *         for k in range(c):
@@ -3759,7 +3737,7 @@ __pyx_t_19 = __pyx_v_j;
       }
   }
 
-  /* "st_utils.pyx":55
+  /* "st_utils.pyx":54
  *             else:
  *                 wf[j, k] = 0
  *     return np.asarray(wf)             # <<<<<<<<<<<<<<
@@ -3767,12 +3745,12 @@ __pyx_t_19 = __pyx_v_j;
  * cdef float_t min_float(float_t* array, int_t a) nogil:
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_wf, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float32_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float32_t, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_wf, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float_t, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_4 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
@@ -3787,17 +3765,17 @@ __pyx_t_19 = __pyx_v_j;
   __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, 55, __pyx_L1_error)
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "st_utils.pyx":35
+  /* "st_utils.pyx":34
  *     return array[k]
  * 
- * def make_whitefield_st(float32_t[:, :, ::1] data, bool_t[:, ::1] mask):             # <<<<<<<<<<<<<<
+ * def make_whitefield_st(float_t[:, :, ::1] data, bool_t[:, ::1] mask):             # <<<<<<<<<<<<<<
  *     """
  *     Return whitefield based on median filtering of the stack of frames
  */
@@ -3825,7 +3803,7 @@ __pyx_t_19 = __pyx_v_j;
   return __pyx_r;
 }
 
-/* "st_utils.pyx":57
+/* "st_utils.pyx":56
  *     return np.asarray(wf)
  * 
  * cdef float_t min_float(float_t* array, int_t a) nogil:             # <<<<<<<<<<<<<<
@@ -3842,7 +3820,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_min_float(__pyx_t_8st_utils_f
   __pyx_t_8st_utils_int_t __pyx_t_3;
   int __pyx_t_4;
 
-  /* "st_utils.pyx":60
+  /* "st_utils.pyx":59
  *     cdef:
  *         int_t i
  *         float_t mv = array[0]             # <<<<<<<<<<<<<<
@@ -3851,7 +3829,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_min_float(__pyx_t_8st_utils_f
  */
   __pyx_v_mv = (__pyx_v_array[0]);
 
-  /* "st_utils.pyx":61
+  /* "st_utils.pyx":60
  *         int_t i
  *         float_t mv = array[0]
  *     for i in range(a):             # <<<<<<<<<<<<<<
@@ -3863,7 +3841,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_min_float(__pyx_t_8st_utils_f
   for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
     __pyx_v_i = __pyx_t_3;
 
-    /* "st_utils.pyx":62
+    /* "st_utils.pyx":61
  *         float_t mv = array[0]
  *     for i in range(a):
  *         if array[i] < mv:             # <<<<<<<<<<<<<<
@@ -3873,7 +3851,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_min_float(__pyx_t_8st_utils_f
     __pyx_t_4 = (((__pyx_v_array[__pyx_v_i]) < __pyx_v_mv) != 0);
     if (__pyx_t_4) {
 
-      /* "st_utils.pyx":63
+      /* "st_utils.pyx":62
  *     for i in range(a):
  *         if array[i] < mv:
  *             mv = array[i]             # <<<<<<<<<<<<<<
@@ -3882,7 +3860,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_min_float(__pyx_t_8st_utils_f
  */
       __pyx_v_mv = (__pyx_v_array[__pyx_v_i]);
 
-      /* "st_utils.pyx":62
+      /* "st_utils.pyx":61
  *         float_t mv = array[0]
  *     for i in range(a):
  *         if array[i] < mv:             # <<<<<<<<<<<<<<
@@ -3892,7 +3870,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_min_float(__pyx_t_8st_utils_f
     }
   }
 
-  /* "st_utils.pyx":64
+  /* "st_utils.pyx":63
  *         if array[i] < mv:
  *             mv = array[i]
  *     return mv             # <<<<<<<<<<<<<<
@@ -3902,7 +3880,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_min_float(__pyx_t_8st_utils_f
   __pyx_r = __pyx_v_mv;
   goto __pyx_L0;
 
-  /* "st_utils.pyx":57
+  /* "st_utils.pyx":56
  *     return np.asarray(wf)
  * 
  * cdef float_t min_float(float_t* array, int_t a) nogil:             # <<<<<<<<<<<<<<
@@ -3915,7 +3893,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_min_float(__pyx_t_8st_utils_f
   return __pyx_r;
 }
 
-/* "st_utils.pyx":66
+/* "st_utils.pyx":65
  *     return mv
  * 
  * cdef float_t max_float(float_t* array, int_t a) nogil:             # <<<<<<<<<<<<<<
@@ -3932,7 +3910,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_f
   __pyx_t_8st_utils_int_t __pyx_t_3;
   int __pyx_t_4;
 
-  /* "st_utils.pyx":69
+  /* "st_utils.pyx":68
  *     cdef:
  *         int_t i
  *         float_t mv = array[0]             # <<<<<<<<<<<<<<
@@ -3941,7 +3919,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_f
  */
   __pyx_v_mv = (__pyx_v_array[0]);
 
-  /* "st_utils.pyx":70
+  /* "st_utils.pyx":69
  *         int_t i
  *         float_t mv = array[0]
  *     for i in range(a):             # <<<<<<<<<<<<<<
@@ -3953,7 +3931,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_f
   for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
     __pyx_v_i = __pyx_t_3;
 
-    /* "st_utils.pyx":71
+    /* "st_utils.pyx":70
  *         float_t mv = array[0]
  *     for i in range(a):
  *         if array[i] > mv:             # <<<<<<<<<<<<<<
@@ -3963,7 +3941,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_f
     __pyx_t_4 = (((__pyx_v_array[__pyx_v_i]) > __pyx_v_mv) != 0);
     if (__pyx_t_4) {
 
-      /* "st_utils.pyx":72
+      /* "st_utils.pyx":71
  *     for i in range(a):
  *         if array[i] > mv:
  *             mv = array[i]             # <<<<<<<<<<<<<<
@@ -3972,7 +3950,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_f
  */
       __pyx_v_mv = (__pyx_v_array[__pyx_v_i]);
 
-      /* "st_utils.pyx":71
+      /* "st_utils.pyx":70
  *         float_t mv = array[0]
  *     for i in range(a):
  *         if array[i] > mv:             # <<<<<<<<<<<<<<
@@ -3982,7 +3960,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_f
     }
   }
 
-  /* "st_utils.pyx":73
+  /* "st_utils.pyx":72
  *         if array[i] > mv:
  *             mv = array[i]
  *     return mv             # <<<<<<<<<<<<<<
@@ -3992,7 +3970,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_f
   __pyx_r = __pyx_v_mv;
   goto __pyx_L0;
 
-  /* "st_utils.pyx":66
+  /* "st_utils.pyx":65
  *     return mv
  * 
  * cdef float_t max_float(float_t* array, int_t a) nogil:             # <<<<<<<<<<<<<<
@@ -4005,7 +3983,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_f
   return __pyx_r;
 }
 
-/* "st_utils.pyx":75
+/* "st_utils.pyx":74
  *     return mv
  * 
  * cdef float_t rbf(float_t dx, float_t ls) nogil:             # <<<<<<<<<<<<<<
@@ -4016,7 +3994,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_max_float(__pyx_t_8st_utils_f
 static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_rbf(__pyx_t_8st_utils_float_t __pyx_v_dx, __pyx_t_8st_utils_float_t __pyx_v_ls) {
   __pyx_t_8st_utils_float_t __pyx_r;
 
-  /* "st_utils.pyx":76
+  /* "st_utils.pyx":75
  * 
  * cdef float_t rbf(float_t dx, float_t ls) nogil:
  *     return exp(-dx**2 / 2 / ls**2) / sqrt(2 * pi) / ls             # <<<<<<<<<<<<<<
@@ -4026,7 +4004,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_rbf(__pyx_t_8st_utils_float_t
   __pyx_r = (((__pyx_t_8st_utils_float_t)(exp((((-pow(__pyx_v_dx, 2.0)) / 2.0) / pow(__pyx_v_ls, 2.0))) / sqrt((2.0 * M_PI)))) / __pyx_v_ls);
   goto __pyx_L0;
 
-  /* "st_utils.pyx":75
+  /* "st_utils.pyx":74
  *     return mv
  * 
  * cdef float_t rbf(float_t dx, float_t ls) nogil:             # <<<<<<<<<<<<<<
@@ -4039,7 +4017,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_rbf(__pyx_t_8st_utils_float_t
   return __pyx_r;
 }
 
-/* "st_utils.pyx":78
+/* "st_utils.pyx":77
  *     return exp(-dx**2 / 2 / ls**2) / sqrt(2 * pi) / ls
  * 
  * cdef void frame_reference(float_t[:, ::1] I0, float_t[:, ::1] w0, float_t[:, ::1] I, float_t[:, ::1] W,             # <<<<<<<<<<<<<<
@@ -4094,7 +4072,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
   __pyx_t_8st_utils_int_t __pyx_t_27;
   __pyx_t_8st_utils_int_t __pyx_t_28;
 
-  /* "st_utils.pyx":81
+  /* "st_utils.pyx":80
  *                           float_t[:, :, ::1] u, float_t di, float_t dj, float_t ls) nogil:
  *     cdef:
  *         int_t b = I.shape[0], c = I.shape[1], j, k, jj, kk, j0, k0             # <<<<<<<<<<<<<<
@@ -4104,7 +4082,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
   __pyx_v_b = (__pyx_v_I.shape[0]);
   __pyx_v_c = (__pyx_v_I.shape[1]);
 
-  /* "st_utils.pyx":82
+  /* "st_utils.pyx":81
  *     cdef:
  *         int_t b = I.shape[0], c = I.shape[1], j, k, jj, kk, j0, k0
  *         int_t aa = I0.shape[0], bb = I0.shape[1], jj0, jj1, kk0, kk1             # <<<<<<<<<<<<<<
@@ -4114,7 +4092,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
   __pyx_v_aa = (__pyx_v_I0.shape[0]);
   __pyx_v_bb = (__pyx_v_I0.shape[1]);
 
-  /* "st_utils.pyx":83
+  /* "st_utils.pyx":82
  *         int_t b = I.shape[0], c = I.shape[1], j, k, jj, kk, j0, k0
  *         int_t aa = I0.shape[0], bb = I0.shape[1], jj0, jj1, kk0, kk1
  *         int_t dn = <int_t>(ceil(4 * ls))             # <<<<<<<<<<<<<<
@@ -4123,7 +4101,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
  */
   __pyx_v_dn = ((__pyx_t_8st_utils_int_t)ceil((4.0 * __pyx_v_ls)));
 
-  /* "st_utils.pyx":85
+  /* "st_utils.pyx":84
  *         int_t dn = <int_t>(ceil(4 * ls))
  *         float_t ss, fs
  *     for j in range(b):             # <<<<<<<<<<<<<<
@@ -4135,7 +4113,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
   for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
     __pyx_v_j = __pyx_t_3;
 
-    /* "st_utils.pyx":86
+    /* "st_utils.pyx":85
  *         float_t ss, fs
  *     for j in range(b):
  *         for k in range(c):             # <<<<<<<<<<<<<<
@@ -4147,7 +4125,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
     for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
       __pyx_v_k = __pyx_t_6;
 
-      /* "st_utils.pyx":87
+      /* "st_utils.pyx":86
  *     for j in range(b):
  *         for k in range(c):
  *             ss = u[0, j, k] - di             # <<<<<<<<<<<<<<
@@ -4159,7 +4137,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
       __pyx_t_9 = __pyx_v_k;
       __pyx_v_ss = ((*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_7 * __pyx_v_u.strides[0]) ) + __pyx_t_8 * __pyx_v_u.strides[1]) )) + __pyx_t_9)) ))) - __pyx_v_di);
 
-      /* "st_utils.pyx":88
+      /* "st_utils.pyx":87
  *         for k in range(c):
  *             ss = u[0, j, k] - di
  *             fs = u[1, j, k] - dj             # <<<<<<<<<<<<<<
@@ -4171,7 +4149,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
       __pyx_t_12 = __pyx_v_k;
       __pyx_v_fs = ((*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_10 * __pyx_v_u.strides[0]) ) + __pyx_t_11 * __pyx_v_u.strides[1]) )) + __pyx_t_12)) ))) - __pyx_v_dj);
 
-      /* "st_utils.pyx":89
+      /* "st_utils.pyx":88
  *             ss = u[0, j, k] - di
  *             fs = u[1, j, k] - dj
  *             j0 = <int_t>(ss) + 1             # <<<<<<<<<<<<<<
@@ -4180,7 +4158,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
  */
       __pyx_v_j0 = (((__pyx_t_8st_utils_int_t)__pyx_v_ss) + 1);
 
-      /* "st_utils.pyx":90
+      /* "st_utils.pyx":89
  *             fs = u[1, j, k] - dj
  *             j0 = <int_t>(ss) + 1
  *             k0 = <int_t>(fs) + 1             # <<<<<<<<<<<<<<
@@ -4189,7 +4167,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
  */
       __pyx_v_k0 = (((__pyx_t_8st_utils_int_t)__pyx_v_fs) + 1);
 
-      /* "st_utils.pyx":91
+      /* "st_utils.pyx":90
  *             j0 = <int_t>(ss) + 1
  *             k0 = <int_t>(fs) + 1
  *             jj0 = j0 - dn if j0 - dn > 0 else 0             # <<<<<<<<<<<<<<
@@ -4203,7 +4181,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
       }
       __pyx_v_jj0 = __pyx_t_13;
 
-      /* "st_utils.pyx":92
+      /* "st_utils.pyx":91
  *             k0 = <int_t>(fs) + 1
  *             jj0 = j0 - dn if j0 - dn > 0 else 0
  *             jj1 = j0 + dn if j0 + dn < aa else aa             # <<<<<<<<<<<<<<
@@ -4217,7 +4195,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
       }
       __pyx_v_jj1 = __pyx_t_13;
 
-      /* "st_utils.pyx":93
+      /* "st_utils.pyx":92
  *             jj0 = j0 - dn if j0 - dn > 0 else 0
  *             jj1 = j0 + dn if j0 + dn < aa else aa
  *             kk0 = k0 - dn if k0 - dn > 0 else 0             # <<<<<<<<<<<<<<
@@ -4231,7 +4209,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
       }
       __pyx_v_kk0 = __pyx_t_13;
 
-      /* "st_utils.pyx":94
+      /* "st_utils.pyx":93
  *             jj1 = j0 + dn if j0 + dn < aa else aa
  *             kk0 = k0 - dn if k0 - dn > 0 else 0
  *             kk1 = k0 + dn if k0 + dn < bb else bb             # <<<<<<<<<<<<<<
@@ -4245,7 +4223,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
       }
       __pyx_v_kk1 = __pyx_t_13;
 
-      /* "st_utils.pyx":95
+      /* "st_utils.pyx":94
  *             kk0 = k0 - dn if k0 - dn > 0 else 0
  *             kk1 = k0 + dn if k0 + dn < bb else bb
  *             for jj in range(jj0, jj1):             # <<<<<<<<<<<<<<
@@ -4257,7 +4235,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
       for (__pyx_t_15 = __pyx_v_jj0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
         __pyx_v_jj = __pyx_t_15;
 
-        /* "st_utils.pyx":96
+        /* "st_utils.pyx":95
  *             kk1 = k0 + dn if k0 + dn < bb else bb
  *             for jj in range(jj0, jj1):
  *                 for kk in range(kk0, kk1):             # <<<<<<<<<<<<<<
@@ -4269,7 +4247,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
         for (__pyx_t_18 = __pyx_v_kk0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) {
           __pyx_v_kk = __pyx_t_18;
 
-          /* "st_utils.pyx":97
+          /* "st_utils.pyx":96
  *             for jj in range(jj0, jj1):
  *                 for kk in range(kk0, kk1):
  *                     I0[jj, kk] += I[j, k] * W[j, k] * rbf(ss - jj, ls) * rbf(fs - kk, ls)             # <<<<<<<<<<<<<<
@@ -4284,7 +4262,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
           __pyx_t_24 = __pyx_v_kk;
           *((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I0.data + __pyx_t_23 * __pyx_v_I0.strides[0]) )) + __pyx_t_24)) )) += ((((*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I.data + __pyx_t_19 * __pyx_v_I.strides[0]) )) + __pyx_t_20)) ))) * (*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_W.data + __pyx_t_21 * __pyx_v_W.strides[0]) )) + __pyx_t_22)) )))) * __pyx_f_8st_utils_rbf((__pyx_v_ss - __pyx_v_jj), __pyx_v_ls)) * __pyx_f_8st_utils_rbf((__pyx_v_fs - __pyx_v_kk), __pyx_v_ls));
 
-          /* "st_utils.pyx":98
+          /* "st_utils.pyx":97
  *                 for kk in range(kk0, kk1):
  *                     I0[jj, kk] += I[j, k] * W[j, k] * rbf(ss - jj, ls) * rbf(fs - kk, ls)
  *                     w0[jj, kk] += W[j, k]**2 * rbf(ss - jj, ls) * rbf(fs - kk, ls)             # <<<<<<<<<<<<<<
@@ -4301,7 +4279,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
     }
   }
 
-  /* "st_utils.pyx":78
+  /* "st_utils.pyx":77
  *     return exp(-dx**2 / 2 / ls**2) / sqrt(2 * pi) / ls
  * 
  * cdef void frame_reference(float_t[:, ::1] I0, float_t[:, ::1] w0, float_t[:, ::1] I, float_t[:, ::1] W,             # <<<<<<<<<<<<<<
@@ -4312,7 +4290,7 @@ static void __pyx_f_8st_utils_frame_reference(__Pyx_memviewslice __pyx_v_I0, __P
   /* function exit code */
 }
 
-/* "st_utils.pyx":100
+/* "st_utils.pyx":99
  *                     w0[jj, kk] += W[j, k]**2 * rbf(ss - jj, ls) * rbf(fs - kk, ls)
  * 
  * def make_reference(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, :, ::1] u,             # <<<<<<<<<<<<<<
@@ -4365,25 +4343,25 @@ static PyObject *__pyx_pw_8st_utils_3make_reference(PyObject *__pyx_self, PyObje
         case  1:
         if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_W)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, 1); __PYX_ERR(0, 100, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, 1); __PYX_ERR(0, 99, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_u)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, 2); __PYX_ERR(0, 100, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, 2); __PYX_ERR(0, 99, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
         if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_di)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, 3); __PYX_ERR(0, 100, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, 3); __PYX_ERR(0, 99, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
         if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dj)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, 4); __PYX_ERR(0, 100, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, 4); __PYX_ERR(0, 99, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  5:
@@ -4393,7 +4371,7 @@ static PyObject *__pyx_pw_8st_utils_3make_reference(PyObject *__pyx_self, PyObje
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_reference") < 0)) __PYX_ERR(0, 100, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_reference") < 0)) __PYX_ERR(0, 99, __pyx_L3_error)
       }
     } else {
       switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -4408,20 +4386,20 @@ static PyObject *__pyx_pw_8st_utils_3make_reference(PyObject *__pyx_self, PyObje
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_I_n = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I_n.memview)) __PYX_ERR(0, 100, __pyx_L3_error)
-    __pyx_v_W = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_W.memview)) __PYX_ERR(0, 100, __pyx_L3_error)
-    __pyx_v_u = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_u.memview)) __PYX_ERR(0, 100, __pyx_L3_error)
-    __pyx_v_di = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_di.memview)) __PYX_ERR(0, 101, __pyx_L3_error)
-    __pyx_v_dj = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[4], PyBUF_WRITABLE); if (unlikely(!__pyx_v_dj.memview)) __PYX_ERR(0, 101, __pyx_L3_error)
+    __pyx_v_I_n = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I_n.memview)) __PYX_ERR(0, 99, __pyx_L3_error)
+    __pyx_v_W = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_W.memview)) __PYX_ERR(0, 99, __pyx_L3_error)
+    __pyx_v_u = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_u.memview)) __PYX_ERR(0, 99, __pyx_L3_error)
+    __pyx_v_di = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_di.memview)) __PYX_ERR(0, 100, __pyx_L3_error)
+    __pyx_v_dj = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[4], PyBUF_WRITABLE); if (unlikely(!__pyx_v_dj.memview)) __PYX_ERR(0, 100, __pyx_L3_error)
     if (values[5]) {
-      __pyx_v_ls = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_ls == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 101, __pyx_L3_error)
+      __pyx_v_ls = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_ls == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L3_error)
     } else {
       __pyx_v_ls = ((__pyx_t_8st_utils_float_t)((double)2.5));
     }
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 100, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("make_reference", 0, 5, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 99, __pyx_L3_error)
   __pyx_L3_error:;
   __Pyx_AddTraceback("st_utils.make_reference", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
@@ -4492,7 +4470,7 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
   PyObject *__pyx_t_42 = NULL;
   __Pyx_RefNannySetupContext("make_reference", 0);
 
-  /* "st_utils.pyx":112
+  /* "st_utils.pyx":111
  *     """
  *     cdef:
  *         int_t a = I_n.shape[0], b = I_n.shape[1], c = I_n.shape[2], i, j             # <<<<<<<<<<<<<<
@@ -4503,7 +4481,7 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
   __pyx_v_b = (__pyx_v_I_n.shape[1]);
   __pyx_v_c = (__pyx_v_I_n.shape[2]);
 
-  /* "st_utils.pyx":113
+  /* "st_utils.pyx":112
  *     cdef:
  *         int_t a = I_n.shape[0], b = I_n.shape[1], c = I_n.shape[2], i, j
  *         float_t n0 = -min_float(&u[0, 0, 0], b * c) + max_float(&di[0], a)             # <<<<<<<<<<<<<<
@@ -4516,7 +4494,7 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
   __pyx_t_4 = 0;
   __pyx_v_n0 = ((-__pyx_f_8st_utils_min_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_1 * __pyx_v_u.strides[0]) ) + __pyx_t_2 * __pyx_v_u.strides[1]) )) + __pyx_t_3)) )))), (__pyx_v_b * __pyx_v_c))) + __pyx_f_8st_utils_max_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_di.data) + __pyx_t_4)) )))), __pyx_v_a));
 
-  /* "st_utils.pyx":114
+  /* "st_utils.pyx":113
  *         int_t a = I_n.shape[0], b = I_n.shape[1], c = I_n.shape[2], i, j
  *         float_t n0 = -min_float(&u[0, 0, 0], b * c) + max_float(&di[0], a)
  *         float_t m0 = -min_float(&u[1, 0, 0], b * c) + max_float(&dj[0], a)             # <<<<<<<<<<<<<<
@@ -4529,7 +4507,7 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
   __pyx_t_8 = 0;
   __pyx_v_m0 = ((-__pyx_f_8st_utils_min_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_5 * __pyx_v_u.strides[0]) ) + __pyx_t_6 * __pyx_v_u.strides[1]) )) + __pyx_t_7)) )))), (__pyx_v_b * __pyx_v_c))) + __pyx_f_8st_utils_max_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_dj.data) + __pyx_t_8)) )))), __pyx_v_a));
 
-  /* "st_utils.pyx":115
+  /* "st_utils.pyx":114
  *         float_t n0 = -min_float(&u[0, 0, 0], b * c) + max_float(&di[0], a)
  *         float_t m0 = -min_float(&u[1, 0, 0], b * c) + max_float(&dj[0], a)
  *         int_t aa = <int_t>(max_float(&u[0, 0, 0], b * c) - min_float(&di[0], a) + n0) + 1             # <<<<<<<<<<<<<<
@@ -4542,7 +4520,7 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
   __pyx_t_12 = 0;
   __pyx_v_aa = (((__pyx_t_8st_utils_int_t)((__pyx_f_8st_utils_max_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_9 * __pyx_v_u.strides[0]) ) + __pyx_t_10 * __pyx_v_u.strides[1]) )) + __pyx_t_11)) )))), (__pyx_v_b * __pyx_v_c)) - __pyx_f_8st_utils_min_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_di.data) + __pyx_t_12)) )))), __pyx_v_a)) + __pyx_v_n0)) + 1);
 
-  /* "st_utils.pyx":116
+  /* "st_utils.pyx":115
  *         float_t m0 = -min_float(&u[1, 0, 0], b * c) + max_float(&dj[0], a)
  *         int_t aa = <int_t>(max_float(&u[0, 0, 0], b * c) - min_float(&di[0], a) + n0) + 1
  *         int_t bb = <int_t>(max_float(&u[1, 0, 0], b * c) - min_float(&dj[0], a) + m0) + 1             # <<<<<<<<<<<<<<
@@ -4555,23 +4533,23 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
   __pyx_t_16 = 0;
   __pyx_v_bb = (((__pyx_t_8st_utils_int_t)((__pyx_f_8st_utils_max_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_13 * __pyx_v_u.strides[0]) ) + __pyx_t_14 * __pyx_v_u.strides[1]) )) + __pyx_t_15)) )))), (__pyx_v_b * __pyx_v_c)) - __pyx_f_8st_utils_min_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_dj.data) + __pyx_t_16)) )))), __pyx_v_a)) + __pyx_v_m0)) + 1);
 
-  /* "st_utils.pyx":117
+  /* "st_utils.pyx":116
  *         int_t aa = <int_t>(max_float(&u[0, 0, 0], b * c) - min_float(&di[0], a) + n0) + 1
  *         int_t bb = <int_t>(max_float(&u[1, 0, 0], b * c) - min_float(&dj[0], a) + m0) + 1
  *         float_t[:, ::1] I0 = np.zeros((aa, bb), dtype=np.float64)             # <<<<<<<<<<<<<<
  *         float_t[:, ::1] w0 = np.zeros((aa, bb), dtype=np.float64)
  *     for i in range(a):
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_17);
-  __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_zeros); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_zeros); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_18);
   __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
-  __pyx_t_17 = __Pyx_PyInt_From_npy_int64(__pyx_v_aa); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_17 = __Pyx_PyInt_From_npy_int64(__pyx_v_aa); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_17);
-  __pyx_t_19 = __Pyx_PyInt_From_npy_int64(__pyx_v_bb); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_19 = __Pyx_PyInt_From_npy_int64(__pyx_v_bb); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_19);
-  __pyx_t_20 = PyTuple_New(2); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_20 = PyTuple_New(2); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_20);
   __Pyx_GIVEREF(__pyx_t_17);
   PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_17);
@@ -4579,48 +4557,48 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
   PyTuple_SET_ITEM(__pyx_t_20, 1, __pyx_t_19);
   __pyx_t_17 = 0;
   __pyx_t_19 = 0;
-  __pyx_t_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_19);
   __Pyx_GIVEREF(__pyx_t_20);
   PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_20);
   __pyx_t_20 = 0;
-  __pyx_t_20 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_20 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_20);
-  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_np); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_17);
-  __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_float64); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_17, __pyx_n_s_float64); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_21);
   __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
-  if (PyDict_SetItem(__pyx_t_20, __pyx_n_s_dtype, __pyx_t_21) < 0) __PYX_ERR(0, 117, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_20, __pyx_n_s_dtype, __pyx_t_21) < 0) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
-  __pyx_t_21 = __Pyx_PyObject_Call(__pyx_t_18, __pyx_t_19, __pyx_t_20); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_21 = __Pyx_PyObject_Call(__pyx_t_18, __pyx_t_19, __pyx_t_20); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_21);
   __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
   __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
   __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
-  __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(__pyx_t_21, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(__pyx_t_21, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
   __pyx_v_I0 = __pyx_t_22;
   __pyx_t_22.memview = NULL;
   __pyx_t_22.data = NULL;
 
-  /* "st_utils.pyx":118
+  /* "st_utils.pyx":117
  *         int_t bb = <int_t>(max_float(&u[1, 0, 0], b * c) - min_float(&dj[0], a) + m0) + 1
  *         float_t[:, ::1] I0 = np.zeros((aa, bb), dtype=np.float64)
  *         float_t[:, ::1] w0 = np.zeros((aa, bb), dtype=np.float64)             # <<<<<<<<<<<<<<
  *     for i in range(a):
  *         di[i] = di[i] - n0; dj[i] = dj[i] - m0
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_n_s_np); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_n_s_np); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_21);
-  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_n_s_zeros); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_n_s_zeros); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_20);
   __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
-  __pyx_t_21 = __Pyx_PyInt_From_npy_int64(__pyx_v_aa); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __pyx_t_21 = __Pyx_PyInt_From_npy_int64(__pyx_v_aa); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_21);
-  __pyx_t_19 = __Pyx_PyInt_From_npy_int64(__pyx_v_bb); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __pyx_t_19 = __Pyx_PyInt_From_npy_int64(__pyx_v_bb); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_19);
-  __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_18);
   __Pyx_GIVEREF(__pyx_t_21);
   PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_21);
@@ -4628,32 +4606,32 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
   PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_19);
   __pyx_t_21 = 0;
   __pyx_t_19 = 0;
-  __pyx_t_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __pyx_t_19 = PyTuple_New(1); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_19);
   __Pyx_GIVEREF(__pyx_t_18);
   PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_18);
   __pyx_t_18 = 0;
-  __pyx_t_18 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __pyx_t_18 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_18);
-  __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_n_s_np); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_n_s_np); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_21);
-  __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_n_s_float64); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_n_s_float64); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_17);
   __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
-  if (PyDict_SetItem(__pyx_t_18, __pyx_n_s_dtype, __pyx_t_17) < 0) __PYX_ERR(0, 118, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_18, __pyx_n_s_dtype, __pyx_t_17) < 0) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
-  __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_20, __pyx_t_19, __pyx_t_18); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_20, __pyx_t_19, __pyx_t_18); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_17);
   __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
   __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
   __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-  __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(__pyx_t_17, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(__pyx_t_17, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
   __pyx_v_w0 = __pyx_t_22;
   __pyx_t_22.memview = NULL;
   __pyx_t_22.data = NULL;
 
-  /* "st_utils.pyx":119
+  /* "st_utils.pyx":118
  *         float_t[:, ::1] I0 = np.zeros((aa, bb), dtype=np.float64)
  *         float_t[:, ::1] w0 = np.zeros((aa, bb), dtype=np.float64)
  *     for i in range(a):             # <<<<<<<<<<<<<<
@@ -4665,7 +4643,7 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
   for (__pyx_t_25 = 0; __pyx_t_25 < __pyx_t_24; __pyx_t_25+=1) {
     __pyx_v_i = __pyx_t_25;
 
-    /* "st_utils.pyx":120
+    /* "st_utils.pyx":119
  *         float_t[:, ::1] w0 = np.zeros((aa, bb), dtype=np.float64)
  *     for i in range(a):
  *         di[i] = di[i] - n0; dj[i] = dj[i] - m0             # <<<<<<<<<<<<<<
@@ -4679,7 +4657,7 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
     __pyx_t_29 = __pyx_v_i;
     *((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_dj.data) + __pyx_t_29)) )) = ((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_dj.data) + __pyx_t_28)) ))) - __pyx_v_m0);
 
-    /* "st_utils.pyx":121
+    /* "st_utils.pyx":120
  *     for i in range(a):
  *         di[i] = di[i] - n0; dj[i] = dj[i] - m0
  *         frame_reference(I0, w0, I_n[i], W, u, di[i], dj[i], ls)             # <<<<<<<<<<<<<<
@@ -4692,7 +4670,7 @@ static PyObject *__pyx_pf_8st_utils_2make_reference(CYTHON_UNUSED PyObject *__py
     {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_i;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_I_n.strides[0];
-        if ((0)) __PYX_ERR(0, 121, __pyx_L1_error)
+        if ((0)) __PYX_ERR(0, 120, __pyx_L1_error)
         __pyx_t_22.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
@@ -4712,7 +4690,7 @@ __pyx_t_30 = __pyx_v_i;
     __pyx_t_22.data = NULL;
   }
 
-  /* "st_utils.pyx":122
+  /* "st_utils.pyx":121
  *         di[i] = di[i] - n0; dj[i] = dj[i] - m0
  *         frame_reference(I0, w0, I_n[i], W, u, di[i], dj[i], ls)
  *     for i in range(aa):             # <<<<<<<<<<<<<<
@@ -4724,7 +4702,7 @@ __pyx_t_30 = __pyx_v_i;
   for (__pyx_t_25 = 0; __pyx_t_25 < __pyx_t_24; __pyx_t_25+=1) {
     __pyx_v_i = __pyx_t_25;
 
-    /* "st_utils.pyx":123
+    /* "st_utils.pyx":122
  *         frame_reference(I0, w0, I_n[i], W, u, di[i], dj[i], ls)
  *     for i in range(aa):
  *         for j in range(bb):             # <<<<<<<<<<<<<<
@@ -4736,7 +4714,7 @@ __pyx_t_30 = __pyx_v_i;
     for (__pyx_t_34 = 0; __pyx_t_34 < __pyx_t_33; __pyx_t_34+=1) {
       __pyx_v_j = __pyx_t_34;
 
-      /* "st_utils.pyx":124
+      /* "st_utils.pyx":123
  *     for i in range(aa):
  *         for j in range(bb):
  *             if w0[i, j]:             # <<<<<<<<<<<<<<
@@ -4748,7 +4726,7 @@ __pyx_t_30 = __pyx_v_i;
       __pyx_t_37 = ((*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_w0.data + __pyx_t_35 * __pyx_v_w0.strides[0]) )) + __pyx_t_36)) ))) != 0);
       if (__pyx_t_37) {
 
-        /* "st_utils.pyx":125
+        /* "st_utils.pyx":124
  *         for j in range(bb):
  *             if w0[i, j]:
  *                 I0[i, j] /= w0[i, j]             # <<<<<<<<<<<<<<
@@ -4761,7 +4739,7 @@ __pyx_t_30 = __pyx_v_i;
         __pyx_t_41 = __pyx_v_j;
         *((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I0.data + __pyx_t_40 * __pyx_v_I0.strides[0]) )) + __pyx_t_41)) )) /= (*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_w0.data + __pyx_t_38 * __pyx_v_w0.strides[0]) )) + __pyx_t_39)) )));
 
-        /* "st_utils.pyx":124
+        /* "st_utils.pyx":123
  *     for i in range(aa):
  *         for j in range(bb):
  *             if w0[i, j]:             # <<<<<<<<<<<<<<
@@ -4772,7 +4750,7 @@ __pyx_t_30 = __pyx_v_i;
     }
   }
 
-  /* "st_utils.pyx":126
+  /* "st_utils.pyx":125
  *             if w0[i, j]:
  *                 I0[i, j] /= w0[i, j]
  *     return np.asarray(I0), np.asarray(di), np.asarray(dj)             # <<<<<<<<<<<<<<
@@ -4780,12 +4758,12 @@ __pyx_t_30 = __pyx_v_i;
  * cdef float_t mse_bi(float_t[:] I, float_t[:, ::1] I0, float_t W, float_t[::1] di,
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_np); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_np); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_18);
-  __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_asarray); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_asarray); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_19);
   __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-  __pyx_t_18 = __pyx_memoryview_fromslice(__pyx_v_I0, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float_t, 0);; if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_t_18 = __pyx_memoryview_fromslice(__pyx_v_I0, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float_t, 0);; if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_18);
   __pyx_t_20 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_19))) {
@@ -4800,15 +4778,15 @@ __pyx_t_30 = __pyx_v_i;
   __pyx_t_17 = (__pyx_t_20) ? __Pyx_PyObject_Call2Args(__pyx_t_19, __pyx_t_20, __pyx_t_18) : __Pyx_PyObject_CallOneArg(__pyx_t_19, __pyx_t_18);
   __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
   __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-  if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 126, __pyx_L1_error)
+  if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_17);
   __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_np); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_np); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_18);
-  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_asarray); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_asarray); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_20);
   __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-  __pyx_t_18 = __pyx_memoryview_fromslice(__pyx_v_di, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float_t, 0);; if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_t_18 = __pyx_memoryview_fromslice(__pyx_v_di, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float_t, 0);; if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_18);
   __pyx_t_21 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_20))) {
@@ -4823,15 +4801,15 @@ __pyx_t_30 = __pyx_v_i;
   __pyx_t_19 = (__pyx_t_21) ? __Pyx_PyObject_Call2Args(__pyx_t_20, __pyx_t_21, __pyx_t_18) : __Pyx_PyObject_CallOneArg(__pyx_t_20, __pyx_t_18);
   __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
   __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-  if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 126, __pyx_L1_error)
+  if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_19);
   __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_np); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_np); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_18);
-  __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_asarray); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_asarray); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_21);
   __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-  __pyx_t_18 = __pyx_memoryview_fromslice(__pyx_v_dj, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float_t, 0);; if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_t_18 = __pyx_memoryview_fromslice(__pyx_v_dj, 1, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float_t, 0);; if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_18);
   __pyx_t_42 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_21))) {
@@ -4846,10 +4824,10 @@ __pyx_t_30 = __pyx_v_i;
   __pyx_t_20 = (__pyx_t_42) ? __Pyx_PyObject_Call2Args(__pyx_t_21, __pyx_t_42, __pyx_t_18) : __Pyx_PyObject_CallOneArg(__pyx_t_21, __pyx_t_18);
   __Pyx_XDECREF(__pyx_t_42); __pyx_t_42 = 0;
   __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-  if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 126, __pyx_L1_error)
+  if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_20);
   __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
-  __pyx_t_21 = PyTuple_New(3); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_t_21 = PyTuple_New(3); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_21);
   __Pyx_GIVEREF(__pyx_t_17);
   PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_17);
@@ -4864,7 +4842,7 @@ __pyx_t_30 = __pyx_v_i;
   __pyx_t_21 = 0;
   goto __pyx_L0;
 
-  /* "st_utils.pyx":100
+  /* "st_utils.pyx":99
  *                     w0[jj, kk] += W[j, k]**2 * rbf(ss - jj, ls) * rbf(fs - kk, ls)
  * 
  * def make_reference(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, :, ::1] u,             # <<<<<<<<<<<<<<
@@ -4896,7 +4874,7 @@ __pyx_t_30 = __pyx_v_i;
   return __pyx_r;
 }
 
-/* "st_utils.pyx":128
+/* "st_utils.pyx":127
  *     return np.asarray(I0), np.asarray(di), np.asarray(dj)
  * 
  * cdef float_t mse_bi(float_t[:] I, float_t[:, ::1] I0, float_t W, float_t[::1] di,             # <<<<<<<<<<<<<<
@@ -4939,7 +4917,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
   __pyx_t_8st_utils_int_t __pyx_t_16;
   __pyx_t_8st_utils_int_t __pyx_t_17;
 
-  /* "st_utils.pyx":131
+  /* "st_utils.pyx":130
  *                     float_t[::1] dj, float_t ux, float_t uy) nogil:
  *     cdef:
  *         int_t a = I.shape[0], aa = I0.shape[0], bb = I0.shape[1]             # <<<<<<<<<<<<<<
@@ -4950,7 +4928,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
   __pyx_v_aa = (__pyx_v_I0.shape[0]);
   __pyx_v_bb = (__pyx_v_I0.shape[1]);
 
-  /* "st_utils.pyx":133
+  /* "st_utils.pyx":132
  *         int_t a = I.shape[0], aa = I0.shape[0], bb = I0.shape[1]
  *         int_t i, ss0, ss1, fs0, fs1
  *         float_t mse = 0, var = 0, ss, fs, dss, dfs, I0_bi             # <<<<<<<<<<<<<<
@@ -4960,7 +4938,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
   __pyx_v_mse = 0.0;
   __pyx_v_var = 0.0;
 
-  /* "st_utils.pyx":134
+  /* "st_utils.pyx":133
  *         int_t i, ss0, ss1, fs0, fs1
  *         float_t mse = 0, var = 0, ss, fs, dss, dfs, I0_bi
  *     for i in range(a):             # <<<<<<<<<<<<<<
@@ -4972,7 +4950,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
   for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
     __pyx_v_i = __pyx_t_3;
 
-    /* "st_utils.pyx":135
+    /* "st_utils.pyx":134
  *         float_t mse = 0, var = 0, ss, fs, dss, dfs, I0_bi
  *     for i in range(a):
  *         ss = ux - di[i]             # <<<<<<<<<<<<<<
@@ -4982,7 +4960,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
     __pyx_t_4 = __pyx_v_i;
     __pyx_v_ss = (__pyx_v_ux - (*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_di.data) + __pyx_t_4)) ))));
 
-    /* "st_utils.pyx":136
+    /* "st_utils.pyx":135
  *     for i in range(a):
  *         ss = ux - di[i]
  *         fs = uy - dj[i]             # <<<<<<<<<<<<<<
@@ -4992,7 +4970,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
     __pyx_t_5 = __pyx_v_i;
     __pyx_v_fs = (__pyx_v_uy - (*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_dj.data) + __pyx_t_5)) ))));
 
-    /* "st_utils.pyx":137
+    /* "st_utils.pyx":136
  *         ss = ux - di[i]
  *         fs = uy - dj[i]
  *         if ss >= 0 and ss <= aa - 1 and fs >= 0 and fs <= bb - 1:             # <<<<<<<<<<<<<<
@@ -5022,7 +5000,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
     __pyx_L6_bool_binop_done:;
     if (__pyx_t_6) {
 
-      /* "st_utils.pyx":138
+      /* "st_utils.pyx":137
  *         fs = uy - dj[i]
  *         if ss >= 0 and ss <= aa - 1 and fs >= 0 and fs <= bb - 1:
  *             dss = ss - floor(ss)             # <<<<<<<<<<<<<<
@@ -5031,7 +5009,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
  */
       __pyx_v_dss = (__pyx_v_ss - floor(__pyx_v_ss));
 
-      /* "st_utils.pyx":139
+      /* "st_utils.pyx":138
  *         if ss >= 0 and ss <= aa - 1 and fs >= 0 and fs <= bb - 1:
  *             dss = ss - floor(ss)
  *             dfs = fs - floor(fs)             # <<<<<<<<<<<<<<
@@ -5040,7 +5018,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
  */
       __pyx_v_dfs = (__pyx_v_fs - floor(__pyx_v_fs));
 
-      /* "st_utils.pyx":140
+      /* "st_utils.pyx":139
  *             dss = ss - floor(ss)
  *             dfs = fs - floor(fs)
  *             if dss:             # <<<<<<<<<<<<<<
@@ -5050,7 +5028,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       __pyx_t_6 = (__pyx_v_dss != 0);
       if (__pyx_t_6) {
 
-        /* "st_utils.pyx":141
+        /* "st_utils.pyx":140
  *             dfs = fs - floor(fs)
  *             if dss:
  *                 ss0 = <int_t>(floor(ss)); ss1 = ss0 + 1             # <<<<<<<<<<<<<<
@@ -5060,7 +5038,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
         __pyx_v_ss0 = ((__pyx_t_8st_utils_int_t)floor(__pyx_v_ss));
         __pyx_v_ss1 = (__pyx_v_ss0 + 1);
 
-        /* "st_utils.pyx":140
+        /* "st_utils.pyx":139
  *             dss = ss - floor(ss)
  *             dfs = fs - floor(fs)
  *             if dss:             # <<<<<<<<<<<<<<
@@ -5070,7 +5048,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
         goto __pyx_L10;
       }
 
-      /* "st_utils.pyx":143
+      /* "st_utils.pyx":142
  *                 ss0 = <int_t>(floor(ss)); ss1 = ss0 + 1
  *             else:
  *                 ss0 = <int_t>(ss); ss1 = ss0             # <<<<<<<<<<<<<<
@@ -5083,7 +5061,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       }
       __pyx_L10:;
 
-      /* "st_utils.pyx":144
+      /* "st_utils.pyx":143
  *             else:
  *                 ss0 = <int_t>(ss); ss1 = ss0
  *             if dfs:             # <<<<<<<<<<<<<<
@@ -5093,7 +5071,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       __pyx_t_6 = (__pyx_v_dfs != 0);
       if (__pyx_t_6) {
 
-        /* "st_utils.pyx":145
+        /* "st_utils.pyx":144
  *                 ss0 = <int_t>(ss); ss1 = ss0
  *             if dfs:
  *                 fs0 = <int_t>(floor(fs)); fs1 = fs0 + 1             # <<<<<<<<<<<<<<
@@ -5103,7 +5081,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
         __pyx_v_fs0 = ((__pyx_t_8st_utils_int_t)floor(__pyx_v_fs));
         __pyx_v_fs1 = (__pyx_v_fs0 + 1);
 
-        /* "st_utils.pyx":144
+        /* "st_utils.pyx":143
  *             else:
  *                 ss0 = <int_t>(ss); ss1 = ss0
  *             if dfs:             # <<<<<<<<<<<<<<
@@ -5113,7 +5091,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
         goto __pyx_L11;
       }
 
-      /* "st_utils.pyx":147
+      /* "st_utils.pyx":146
  *                 fs0 = <int_t>(floor(fs)); fs1 = fs0 + 1
  *             else:
  *                 fs0 = <int_t>(fs); fs1 = fs0             # <<<<<<<<<<<<<<
@@ -5126,7 +5104,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       }
       __pyx_L11:;
 
-      /* "st_utils.pyx":148
+      /* "st_utils.pyx":147
  *             else:
  *                 fs0 = <int_t>(fs); fs1 = fs0
  *             I0_bi = (1 - dss) * (1 - dfs) * I0[ss0, fs0] + \             # <<<<<<<<<<<<<<
@@ -5136,7 +5114,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       __pyx_t_8 = __pyx_v_ss0;
       __pyx_t_9 = __pyx_v_fs0;
 
-      /* "st_utils.pyx":149
+      /* "st_utils.pyx":148
  *                 fs0 = <int_t>(fs); fs1 = fs0
  *             I0_bi = (1 - dss) * (1 - dfs) * I0[ss0, fs0] + \
  *                     (1 - dss) * dfs * I0[ss0, fs1] + \             # <<<<<<<<<<<<<<
@@ -5146,7 +5124,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       __pyx_t_10 = __pyx_v_ss0;
       __pyx_t_11 = __pyx_v_fs1;
 
-      /* "st_utils.pyx":150
+      /* "st_utils.pyx":149
  *             I0_bi = (1 - dss) * (1 - dfs) * I0[ss0, fs0] + \
  *                     (1 - dss) * dfs * I0[ss0, fs1] + \
  *                     dss * (1 - dfs) * I0[ss1, fs0] + \             # <<<<<<<<<<<<<<
@@ -5156,7 +5134,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       __pyx_t_12 = __pyx_v_ss1;
       __pyx_t_13 = __pyx_v_fs0;
 
-      /* "st_utils.pyx":151
+      /* "st_utils.pyx":150
  *                     (1 - dss) * dfs * I0[ss0, fs1] + \
  *                     dss * (1 - dfs) * I0[ss1, fs0] + \
  *                     dss * dfs * I0[ss1, fs1]             # <<<<<<<<<<<<<<
@@ -5166,7 +5144,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       __pyx_t_14 = __pyx_v_ss1;
       __pyx_t_15 = __pyx_v_fs1;
 
-      /* "st_utils.pyx":150
+      /* "st_utils.pyx":149
  *             I0_bi = (1 - dss) * (1 - dfs) * I0[ss0, fs0] + \
  *                     (1 - dss) * dfs * I0[ss0, fs1] + \
  *                     dss * (1 - dfs) * I0[ss1, fs0] + \             # <<<<<<<<<<<<<<
@@ -5175,7 +5153,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
  */
       __pyx_v_I0_bi = ((((((1.0 - __pyx_v_dss) * (1.0 - __pyx_v_dfs)) * (*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I0.data + __pyx_t_8 * __pyx_v_I0.strides[0]) )) + __pyx_t_9)) )))) + (((1.0 - __pyx_v_dss) * __pyx_v_dfs) * (*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I0.data + __pyx_t_10 * __pyx_v_I0.strides[0]) )) + __pyx_t_11)) ))))) + ((__pyx_v_dss * (1.0 - __pyx_v_dfs)) * (*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I0.data + __pyx_t_12 * __pyx_v_I0.strides[0]) )) + __pyx_t_13)) ))))) + ((__pyx_v_dss * __pyx_v_dfs) * (*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I0.data + __pyx_t_14 * __pyx_v_I0.strides[0]) )) + __pyx_t_15)) )))));
 
-      /* "st_utils.pyx":152
+      /* "st_utils.pyx":151
  *                     dss * (1 - dfs) * I0[ss1, fs0] + \
  *                     dss * dfs * I0[ss1, fs1]
  *             mse += (I[i] - W * I0_bi)**2             # <<<<<<<<<<<<<<
@@ -5185,7 +5163,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       __pyx_t_16 = __pyx_v_i;
       __pyx_v_mse = (__pyx_v_mse + pow(((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I.data + __pyx_t_16 * __pyx_v_I.strides[0]) ))) - (__pyx_v_W * __pyx_v_I0_bi)), 2.0));
 
-      /* "st_utils.pyx":153
+      /* "st_utils.pyx":152
  *                     dss * dfs * I0[ss1, fs1]
  *             mse += (I[i] - W * I0_bi)**2
  *             var += (I[i] - W)**2             # <<<<<<<<<<<<<<
@@ -5195,7 +5173,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
       __pyx_t_17 = __pyx_v_i;
       __pyx_v_var = (__pyx_v_var + pow(((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I.data + __pyx_t_17 * __pyx_v_I.strides[0]) ))) - __pyx_v_W), 2.0));
 
-      /* "st_utils.pyx":137
+      /* "st_utils.pyx":136
  *         ss = ux - di[i]
  *         fs = uy - dj[i]
  *         if ss >= 0 and ss <= aa - 1 and fs >= 0 and fs <= bb - 1:             # <<<<<<<<<<<<<<
@@ -5205,7 +5183,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
     }
   }
 
-  /* "st_utils.pyx":154
+  /* "st_utils.pyx":153
  *             mse += (I[i] - W * I0_bi)**2
  *             var += (I[i] - W)**2
  *     return mse / var             # <<<<<<<<<<<<<<
@@ -5215,7 +5193,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
   __pyx_r = (__pyx_v_mse / __pyx_v_var);
   goto __pyx_L0;
 
-  /* "st_utils.pyx":128
+  /* "st_utils.pyx":127
  *     return np.asarray(I0), np.asarray(di), np.asarray(dj)
  * 
  * cdef float_t mse_bi(float_t[:] I, float_t[:, ::1] I0, float_t W, float_t[::1] di,             # <<<<<<<<<<<<<<
@@ -5228,7 +5206,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_bi(__Pyx_memviewslice __p
   return __pyx_r;
 }
 
-/* "st_utils.pyx":156
+/* "st_utils.pyx":155
  *     return mse / var
  * 
  * cdef float_t mse_nobi(float_t[:] I, float_t[:, ::1] I0, float_t W, float_t[::1] di,             # <<<<<<<<<<<<<<
@@ -5260,7 +5238,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
   __pyx_t_8st_utils_int_t __pyx_t_10;
   __pyx_t_8st_utils_int_t __pyx_t_11;
 
-  /* "st_utils.pyx":159
+  /* "st_utils.pyx":158
  *                       float_t[::1] dj, float_t ux, float_t uy) nogil:
  *     cdef:
  *         int_t a = I.shape[0], aa = I0.shape[0], bb = I0.shape[1]             # <<<<<<<<<<<<<<
@@ -5271,7 +5249,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
   __pyx_v_aa = (__pyx_v_I0.shape[0]);
   __pyx_v_bb = (__pyx_v_I0.shape[1]);
 
-  /* "st_utils.pyx":161
+  /* "st_utils.pyx":160
  *         int_t a = I.shape[0], aa = I0.shape[0], bb = I0.shape[1]
  *         int_t i, ss0, fs0
  *         float_t mse = 0, var = 0, ss, fs             # <<<<<<<<<<<<<<
@@ -5281,7 +5259,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
   __pyx_v_mse = 0.0;
   __pyx_v_var = 0.0;
 
-  /* "st_utils.pyx":162
+  /* "st_utils.pyx":161
  *         int_t i, ss0, fs0
  *         float_t mse = 0, var = 0, ss, fs
  *     for i in range(a):             # <<<<<<<<<<<<<<
@@ -5293,7 +5271,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
   for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
     __pyx_v_i = __pyx_t_3;
 
-    /* "st_utils.pyx":163
+    /* "st_utils.pyx":162
  *         float_t mse = 0, var = 0, ss, fs
  *     for i in range(a):
  *         ss = ux - di[i]             # <<<<<<<<<<<<<<
@@ -5303,7 +5281,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
     __pyx_t_4 = __pyx_v_i;
     __pyx_v_ss = (__pyx_v_ux - (*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_di.data) + __pyx_t_4)) ))));
 
-    /* "st_utils.pyx":164
+    /* "st_utils.pyx":163
  *     for i in range(a):
  *         ss = ux - di[i]
  *         fs = uy - dj[i]             # <<<<<<<<<<<<<<
@@ -5313,7 +5291,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
     __pyx_t_5 = __pyx_v_i;
     __pyx_v_fs = (__pyx_v_uy - (*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_dj.data) + __pyx_t_5)) ))));
 
-    /* "st_utils.pyx":165
+    /* "st_utils.pyx":164
  *         ss = ux - di[i]
  *         fs = uy - dj[i]
  *         if ss >= 0 and ss <= aa - 1 and fs >= 0 and fs <= bb - 1:             # <<<<<<<<<<<<<<
@@ -5343,7 +5321,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
     __pyx_L6_bool_binop_done:;
     if (__pyx_t_6) {
 
-      /* "st_utils.pyx":166
+      /* "st_utils.pyx":165
  *         fs = uy - dj[i]
  *         if ss >= 0 and ss <= aa - 1 and fs >= 0 and fs <= bb - 1:
  *             ss0 = <int_t>(floor(ss))             # <<<<<<<<<<<<<<
@@ -5352,7 +5330,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
  */
       __pyx_v_ss0 = ((__pyx_t_8st_utils_int_t)floor(__pyx_v_ss));
 
-      /* "st_utils.pyx":167
+      /* "st_utils.pyx":166
  *         if ss >= 0 and ss <= aa - 1 and fs >= 0 and fs <= bb - 1:
  *             ss0 = <int_t>(floor(ss))
  *             fs0 = <int_t>(floor(fs))             # <<<<<<<<<<<<<<
@@ -5361,7 +5339,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
  */
       __pyx_v_fs0 = ((__pyx_t_8st_utils_int_t)floor(__pyx_v_fs));
 
-      /* "st_utils.pyx":168
+      /* "st_utils.pyx":167
  *             ss0 = <int_t>(floor(ss))
  *             fs0 = <int_t>(floor(fs))
  *             mse += (I[i] - W * I0[ss0, fs0])**2             # <<<<<<<<<<<<<<
@@ -5373,7 +5351,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
       __pyx_t_10 = __pyx_v_fs0;
       __pyx_v_mse = (__pyx_v_mse + pow(((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I.data + __pyx_t_8 * __pyx_v_I.strides[0]) ))) - (__pyx_v_W * (*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I0.data + __pyx_t_9 * __pyx_v_I0.strides[0]) )) + __pyx_t_10)) ))))), 2.0));
 
-      /* "st_utils.pyx":169
+      /* "st_utils.pyx":168
  *             fs0 = <int_t>(floor(fs))
  *             mse += (I[i] - W * I0[ss0, fs0])**2
  *             var += (I[i] - W)**2             # <<<<<<<<<<<<<<
@@ -5383,7 +5361,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
       __pyx_t_11 = __pyx_v_i;
       __pyx_v_var = (__pyx_v_var + pow(((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_I.data + __pyx_t_11 * __pyx_v_I.strides[0]) ))) - __pyx_v_W), 2.0));
 
-      /* "st_utils.pyx":165
+      /* "st_utils.pyx":164
  *         ss = ux - di[i]
  *         fs = uy - dj[i]
  *         if ss >= 0 and ss <= aa - 1 and fs >= 0 and fs <= bb - 1:             # <<<<<<<<<<<<<<
@@ -5393,7 +5371,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
     }
   }
 
-  /* "st_utils.pyx":170
+  /* "st_utils.pyx":169
  *             mse += (I[i] - W * I0[ss0, fs0])**2
  *             var += (I[i] - W)**2
  *     return mse / var             # <<<<<<<<<<<<<<
@@ -5403,7 +5381,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
   __pyx_r = (__pyx_v_mse / __pyx_v_var);
   goto __pyx_L0;
 
-  /* "st_utils.pyx":156
+  /* "st_utils.pyx":155
  *     return mse / var
  * 
  * cdef float_t mse_nobi(float_t[:] I, float_t[:, ::1] I0, float_t W, float_t[::1] di,             # <<<<<<<<<<<<<<
@@ -5416,7 +5394,7 @@ static __pyx_t_8st_utils_float_t __pyx_f_8st_utils_mse_nobi(__Pyx_memviewslice _
   return __pyx_r;
 }
 
-/* "st_utils.pyx":172
+/* "st_utils.pyx":171
  *     return mse / var
  * 
  * cdef void search_2d(float_t[:] I, float_t[:, ::1] I0, float_t[::1] di, float_t[::1] dj,             # <<<<<<<<<<<<<<
@@ -5456,7 +5434,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
   Py_ssize_t __pyx_t_20;
   Py_ssize_t __pyx_t_21;
 
-  /* "st_utils.pyx":176
+  /* "st_utils.pyx":175
  *                     float_t dss, float_t dfs) nogil:
  *     cdef:
  *         int_t j = j0, i_min = 0, j_min = 0, i, jj             # <<<<<<<<<<<<<<
@@ -5467,7 +5445,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
   __pyx_v_i_min = 0;
   __pyx_v_j_min = 0;
 
-  /* "st_utils.pyx":177
+  /* "st_utils.pyx":176
  *     cdef:
  *         int_t j = j0, i_min = 0, j_min = 0, i, jj
  *         float_t mse_min = FLOAT_MAX, mse = 0, df_ss, df_fs             # <<<<<<<<<<<<<<
@@ -5477,7 +5455,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
   __pyx_v_mse_min = 1.7976931348623157e+308;
   __pyx_v_mse = 0.0;
 
-  /* "st_utils.pyx":178
+  /* "st_utils.pyx":177
  *         int_t j = j0, i_min = 0, j_min = 0, i, jj
  *         float_t mse_min = FLOAT_MAX, mse = 0, df_ss, df_fs
  *     for i in range(i0, i1):             # <<<<<<<<<<<<<<
@@ -5489,7 +5467,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
   for (__pyx_t_3 = __pyx_v_i0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
     __pyx_v_i = __pyx_t_3;
 
-    /* "st_utils.pyx":179
+    /* "st_utils.pyx":178
  *         float_t mse_min = FLOAT_MAX, mse = 0, df_ss, df_fs
  *     for i in range(i0, i1):
  *         if i - i0:             # <<<<<<<<<<<<<<
@@ -5499,7 +5477,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
     __pyx_t_4 = ((__pyx_v_i - __pyx_v_i0) != 0);
     if (__pyx_t_4) {
 
-      /* "st_utils.pyx":180
+      /* "st_utils.pyx":179
  *     for i in range(i0, i1):
  *         if i - i0:
  *             df_ss = (mse_bi(I, I0, W, di, dj, u[0] + i - 0.5 + dss, u[1] + j) - \             # <<<<<<<<<<<<<<
@@ -5509,7 +5487,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
       __pyx_t_5 = 0;
       __pyx_t_6 = 1;
 
-      /* "st_utils.pyx":181
+      /* "st_utils.pyx":180
  *         if i - i0:
  *             df_ss = (mse_bi(I, I0, W, di, dj, u[0] + i - 0.5 + dss, u[1] + j) - \
  *                      mse_bi(I, I0, W, di, dj, u[0] + i - 0.5 - dss, u[1] + j)) / 2 / dss             # <<<<<<<<<<<<<<
@@ -5519,7 +5497,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
       __pyx_t_7 = 0;
       __pyx_t_8 = 1;
 
-      /* "st_utils.pyx":180
+      /* "st_utils.pyx":179
  *     for i in range(i0, i1):
  *         if i - i0:
  *             df_ss = (mse_bi(I, I0, W, di, dj, u[0] + i - 0.5 + dss, u[1] + j) - \             # <<<<<<<<<<<<<<
@@ -5528,7 +5506,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
  */
       __pyx_v_df_ss = (((__pyx_f_8st_utils_mse_bi(__pyx_v_I, __pyx_v_I0, __pyx_v_W, __pyx_v_di, __pyx_v_dj, ((((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_5 * __pyx_v_u.strides[0]) ))) + __pyx_v_i) - 0.5) + __pyx_v_dss), ((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_6 * __pyx_v_u.strides[0]) ))) + __pyx_v_j)) - __pyx_f_8st_utils_mse_bi(__pyx_v_I, __pyx_v_I0, __pyx_v_W, __pyx_v_di, __pyx_v_dj, ((((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_7 * __pyx_v_u.strides[0]) ))) + __pyx_v_i) - 0.5) - __pyx_v_dss), ((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_8 * __pyx_v_u.strides[0]) ))) + __pyx_v_j))) / 2.0) / __pyx_v_dss);
 
-      /* "st_utils.pyx":182
+      /* "st_utils.pyx":181
  *             df_ss = (mse_bi(I, I0, W, di, dj, u[0] + i - 0.5 + dss, u[1] + j) - \
  *                      mse_bi(I, I0, W, di, dj, u[0] + i - 0.5 - dss, u[1] + j)) / 2 / dss
  *             mse += df_ss             # <<<<<<<<<<<<<<
@@ -5537,7 +5515,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
  */
       __pyx_v_mse = (__pyx_v_mse + __pyx_v_df_ss);
 
-      /* "st_utils.pyx":183
+      /* "st_utils.pyx":182
  *                      mse_bi(I, I0, W, di, dj, u[0] + i - 0.5 - dss, u[1] + j)) / 2 / dss
  *             mse += df_ss
  *             if mse < mse_min:             # <<<<<<<<<<<<<<
@@ -5547,7 +5525,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
       __pyx_t_4 = ((__pyx_v_mse < __pyx_v_mse_min) != 0);
       if (__pyx_t_4) {
 
-        /* "st_utils.pyx":184
+        /* "st_utils.pyx":183
  *             mse += df_ss
  *             if mse < mse_min:
  *                 mse_min = mse; i_min = i; j_min = j             # <<<<<<<<<<<<<<
@@ -5558,7 +5536,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
         __pyx_v_i_min = __pyx_v_i;
         __pyx_v_j_min = __pyx_v_j;
 
-        /* "st_utils.pyx":183
+        /* "st_utils.pyx":182
  *                      mse_bi(I, I0, W, di, dj, u[0] + i - 0.5 - dss, u[1] + j)) / 2 / dss
  *             mse += df_ss
  *             if mse < mse_min:             # <<<<<<<<<<<<<<
@@ -5567,7 +5545,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
  */
       }
 
-      /* "st_utils.pyx":179
+      /* "st_utils.pyx":178
  *         float_t mse_min = FLOAT_MAX, mse = 0, df_ss, df_fs
  *     for i in range(i0, i1):
  *         if i - i0:             # <<<<<<<<<<<<<<
@@ -5576,7 +5554,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
  */
     }
 
-    /* "st_utils.pyx":185
+    /* "st_utils.pyx":184
  *             if mse < mse_min:
  *                 mse_min = mse; i_min = i; j_min = j
  *         if (i - i0) % 2:             # <<<<<<<<<<<<<<
@@ -5586,7 +5564,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
     __pyx_t_4 = (((__pyx_v_i - __pyx_v_i0) % 2) != 0);
     if (__pyx_t_4) {
 
-      /* "st_utils.pyx":186
+      /* "st_utils.pyx":185
  *                 mse_min = mse; i_min = i; j_min = j
  *         if (i - i0) % 2:
  *             for jj in range(j0 + 1, j1):             # <<<<<<<<<<<<<<
@@ -5598,7 +5576,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
       for (__pyx_t_11 = (__pyx_v_j0 + 1); __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
         __pyx_v_jj = __pyx_t_11;
 
-        /* "st_utils.pyx":187
+        /* "st_utils.pyx":186
  *         if (i - i0) % 2:
  *             for jj in range(j0 + 1, j1):
  *                 j = j1 + j0 - jj - 1             # <<<<<<<<<<<<<<
@@ -5607,7 +5585,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
  */
         __pyx_v_j = (((__pyx_v_j1 + __pyx_v_j0) - __pyx_v_jj) - 1);
 
-        /* "st_utils.pyx":188
+        /* "st_utils.pyx":187
  *             for jj in range(j0 + 1, j1):
  *                 j = j1 + j0 - jj - 1
  *                 df_fs = (mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 + dfs) - \             # <<<<<<<<<<<<<<
@@ -5617,7 +5595,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
         __pyx_t_12 = 0;
         __pyx_t_13 = 1;
 
-        /* "st_utils.pyx":189
+        /* "st_utils.pyx":188
  *                 j = j1 + j0 - jj - 1
  *                 df_fs = (mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 + dfs) - \
  *                          mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 - dfs)) / 2 / dfs             # <<<<<<<<<<<<<<
@@ -5627,7 +5605,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
         __pyx_t_14 = 0;
         __pyx_t_15 = 1;
 
-        /* "st_utils.pyx":188
+        /* "st_utils.pyx":187
  *             for jj in range(j0 + 1, j1):
  *                 j = j1 + j0 - jj - 1
  *                 df_fs = (mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 + dfs) - \             # <<<<<<<<<<<<<<
@@ -5636,7 +5614,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
  */
         __pyx_v_df_fs = (((__pyx_f_8st_utils_mse_bi(__pyx_v_I, __pyx_v_I0, __pyx_v_W, __pyx_v_di, __pyx_v_dj, ((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_12 * __pyx_v_u.strides[0]) ))) + __pyx_v_i), ((((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_13 * __pyx_v_u.strides[0]) ))) + __pyx_v_j) - 0.5) + __pyx_v_dfs)) - __pyx_f_8st_utils_mse_bi(__pyx_v_I, __pyx_v_I0, __pyx_v_W, __pyx_v_di, __pyx_v_dj, ((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_14 * __pyx_v_u.strides[0]) ))) + __pyx_v_i), ((((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_15 * __pyx_v_u.strides[0]) ))) + __pyx_v_j) - 0.5) - __pyx_v_dfs))) / 2.0) / __pyx_v_dfs);
 
-        /* "st_utils.pyx":190
+        /* "st_utils.pyx":189
  *                 df_fs = (mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 + dfs) - \
  *                          mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 - dfs)) / 2 / dfs
  *                 mse += df_fs             # <<<<<<<<<<<<<<
@@ -5645,7 +5623,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
  */
         __pyx_v_mse = (__pyx_v_mse + __pyx_v_df_fs);
 
-        /* "st_utils.pyx":191
+        /* "st_utils.pyx":190
  *                          mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 - dfs)) / 2 / dfs
  *                 mse += df_fs
  *                 if mse < mse_min:             # <<<<<<<<<<<<<<
@@ -5655,7 +5633,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
         __pyx_t_4 = ((__pyx_v_mse < __pyx_v_mse_min) != 0);
         if (__pyx_t_4) {
 
-          /* "st_utils.pyx":192
+          /* "st_utils.pyx":191
  *                 mse += df_fs
  *                 if mse < mse_min:
  *                     mse_min = mse; i_min = i; j_min = j             # <<<<<<<<<<<<<<
@@ -5666,7 +5644,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
           __pyx_v_i_min = __pyx_v_i;
           __pyx_v_j_min = __pyx_v_j;
 
-          /* "st_utils.pyx":191
+          /* "st_utils.pyx":190
  *                          mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 - dfs)) / 2 / dfs
  *                 mse += df_fs
  *                 if mse < mse_min:             # <<<<<<<<<<<<<<
@@ -5676,7 +5654,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
         }
       }
 
-      /* "st_utils.pyx":185
+      /* "st_utils.pyx":184
  *             if mse < mse_min:
  *                 mse_min = mse; i_min = i; j_min = j
  *         if (i - i0) % 2:             # <<<<<<<<<<<<<<
@@ -5686,7 +5664,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
       goto __pyx_L7;
     }
 
-    /* "st_utils.pyx":194
+    /* "st_utils.pyx":193
  *                     mse_min = mse; i_min = i; j_min = j
  *         else:
  *             for j in range(j0 + 1, j1):             # <<<<<<<<<<<<<<
@@ -5699,7 +5677,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
       for (__pyx_t_11 = (__pyx_v_j0 + 1); __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
         __pyx_v_j = __pyx_t_11;
 
-        /* "st_utils.pyx":195
+        /* "st_utils.pyx":194
  *         else:
  *             for j in range(j0 + 1, j1):
  *                 df_fs = (mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 + dfs) - \             # <<<<<<<<<<<<<<
@@ -5709,7 +5687,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
         __pyx_t_16 = 0;
         __pyx_t_17 = 1;
 
-        /* "st_utils.pyx":196
+        /* "st_utils.pyx":195
  *             for j in range(j0 + 1, j1):
  *                 df_fs = (mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 + dfs) - \
  *                          mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 - dfs)) / 2 / dfs             # <<<<<<<<<<<<<<
@@ -5719,7 +5697,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
         __pyx_t_18 = 0;
         __pyx_t_19 = 1;
 
-        /* "st_utils.pyx":195
+        /* "st_utils.pyx":194
  *         else:
  *             for j in range(j0 + 1, j1):
  *                 df_fs = (mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 + dfs) - \             # <<<<<<<<<<<<<<
@@ -5728,7 +5706,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
  */
         __pyx_v_df_fs = (((__pyx_f_8st_utils_mse_bi(__pyx_v_I, __pyx_v_I0, __pyx_v_W, __pyx_v_di, __pyx_v_dj, ((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_16 * __pyx_v_u.strides[0]) ))) + __pyx_v_i), ((((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_17 * __pyx_v_u.strides[0]) ))) + __pyx_v_j) - 0.5) + __pyx_v_dfs)) - __pyx_f_8st_utils_mse_bi(__pyx_v_I, __pyx_v_I0, __pyx_v_W, __pyx_v_di, __pyx_v_dj, ((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_18 * __pyx_v_u.strides[0]) ))) + __pyx_v_i), ((((*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_19 * __pyx_v_u.strides[0]) ))) + __pyx_v_j) - 0.5) - __pyx_v_dfs))) / 2.0) / __pyx_v_dfs);
 
-        /* "st_utils.pyx":197
+        /* "st_utils.pyx":196
  *                 df_fs = (mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 + dfs) - \
  *                          mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 - dfs)) / 2 / dfs
  *                 mse += df_fs             # <<<<<<<<<<<<<<
@@ -5737,7 +5715,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
  */
         __pyx_v_mse = (__pyx_v_mse + __pyx_v_df_fs);
 
-        /* "st_utils.pyx":198
+        /* "st_utils.pyx":197
  *                          mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 - dfs)) / 2 / dfs
  *                 mse += df_fs
  *                 if mse < mse_min:             # <<<<<<<<<<<<<<
@@ -5747,7 +5725,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
         __pyx_t_4 = ((__pyx_v_mse < __pyx_v_mse_min) != 0);
         if (__pyx_t_4) {
 
-          /* "st_utils.pyx":199
+          /* "st_utils.pyx":198
  *                 mse += df_fs
  *                 if mse < mse_min:
  *                     mse_min = mse; i_min = i; j_min = j             # <<<<<<<<<<<<<<
@@ -5758,7 +5736,7 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
           __pyx_v_i_min = __pyx_v_i;
           __pyx_v_j_min = __pyx_v_j;
 
-          /* "st_utils.pyx":198
+          /* "st_utils.pyx":197
  *                          mse_bi(I, I0, W, di, dj, u[0] + i, u[1] + j - 0.5 - dfs)) / 2 / dfs
  *                 mse += df_fs
  *                 if mse < mse_min:             # <<<<<<<<<<<<<<
@@ -5771,19 +5749,19 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
     __pyx_L7:;
   }
 
-  /* "st_utils.pyx":200
+  /* "st_utils.pyx":199
  *                 if mse < mse_min:
  *                     mse_min = mse; i_min = i; j_min = j
  *     u[0] += i_min; u[1] += j_min             # <<<<<<<<<<<<<<
  * 
- * def update_pixel_map_search(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,
+ * def update_pixel_map(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,
  */
   __pyx_t_20 = 0;
   *((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_20 * __pyx_v_u.strides[0]) )) += __pyx_v_i_min;
   __pyx_t_21 = 1;
   *((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_u.data + __pyx_t_21 * __pyx_v_u.strides[0]) )) += __pyx_v_j_min;
 
-  /* "st_utils.pyx":172
+  /* "st_utils.pyx":171
  *     return mse / var
  * 
  * cdef void search_2d(float_t[:] I, float_t[:, ::1] I0, float_t[::1] di, float_t[::1] dj,             # <<<<<<<<<<<<<<
@@ -5794,19 +5772,19 @@ static void __pyx_f_8st_utils_search_2d(__Pyx_memviewslice __pyx_v_I, __Pyx_memv
   /* function exit code */
 }
 
-/* "st_utils.pyx":202
+/* "st_utils.pyx":201
  *     u[0] += i_min; u[1] += j_min
  * 
- * def update_pixel_map_search(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
- *                             float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
- *                             float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
+ * def update_pixel_map(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
+ *                      float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
+ *                      float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_8st_utils_5update_pixel_map_search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_8st_utils_4update_pixel_map_search[] = "\n    Update the pixel map\n\n    I_n - measured data\n    W - whitefield\n    I0 - reference image\n    u0 - pixel map\n    di, dj - sample translations along slow and fast axis in pixels\n    dss, dfs - average sample translations along slow and fast axis in pixels\n    wss, wfs - search window size along slow and fast axis\n    ";
-static PyMethodDef __pyx_mdef_8st_utils_5update_pixel_map_search = {"update_pixel_map_search", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8st_utils_5update_pixel_map_search, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8st_utils_4update_pixel_map_search};
-static PyObject *__pyx_pw_8st_utils_5update_pixel_map_search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_8st_utils_5update_pixel_map(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_8st_utils_4update_pixel_map[] = "\n    Update the pixel map\n\n    I_n - measured data\n    W - whitefield\n    I0 - reference image\n    u0 - pixel map\n    di, dj - sample translations along slow and fast axis in pixels\n    dss, dfs - average sample translations along slow and fast axis in pixels\n    wss, wfs - search window size along slow and fast axis\n    ";
+static PyMethodDef __pyx_mdef_8st_utils_5update_pixel_map = {"update_pixel_map", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8st_utils_5update_pixel_map, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8st_utils_4update_pixel_map};
+static PyObject *__pyx_pw_8st_utils_5update_pixel_map(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   __Pyx_memviewslice __pyx_v_I_n = { 0, 0, { 0 }, { 0 }, { 0 } };
   __Pyx_memviewslice __pyx_v_W = { 0, 0, { 0 }, { 0 }, { 0 } };
   __Pyx_memviewslice __pyx_v_I0 = { 0, 0, { 0 }, { 0 }, { 0 } };
@@ -5819,7 +5797,7 @@ static PyObject *__pyx_pw_8st_utils_5update_pixel_map_search(PyObject *__pyx_sel
   __pyx_t_8st_utils_uint_t __pyx_v_wfs;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("update_pixel_map_search (wrapper)", 0);
+  __Pyx_RefNannySetupContext("update_pixel_map (wrapper)", 0);
   {
     static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_I_n,&__pyx_n_s_W,&__pyx_n_s_I0,&__pyx_n_s_u0,&__pyx_n_s_di,&__pyx_n_s_dj,&__pyx_n_s_dss,&__pyx_n_s_dfs,&__pyx_n_s_wss,&__pyx_n_s_wfs,0};
     PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
@@ -5859,43 +5837,43 @@ static PyObject *__pyx_pw_8st_utils_5update_pixel_map_search(PyObject *__pyx_sel
         case  1:
         if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_W)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("update_pixel_map_search", 0, 8, 10, 1); __PYX_ERR(0, 202, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("update_pixel_map", 0, 8, 10, 1); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_I0)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("update_pixel_map_search", 0, 8, 10, 2); __PYX_ERR(0, 202, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("update_pixel_map", 0, 8, 10, 2); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
         if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_u0)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("update_pixel_map_search", 0, 8, 10, 3); __PYX_ERR(0, 202, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("update_pixel_map", 0, 8, 10, 3); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
         if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_di)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("update_pixel_map_search", 0, 8, 10, 4); __PYX_ERR(0, 202, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("update_pixel_map", 0, 8, 10, 4); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  5:
         if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dj)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("update_pixel_map_search", 0, 8, 10, 5); __PYX_ERR(0, 202, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("update_pixel_map", 0, 8, 10, 5); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  6:
         if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dss)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("update_pixel_map_search", 0, 8, 10, 6); __PYX_ERR(0, 202, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("update_pixel_map", 0, 8, 10, 6); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  7:
         if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dfs)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("update_pixel_map_search", 0, 8, 10, 7); __PYX_ERR(0, 202, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("update_pixel_map", 0, 8, 10, 7); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  8:
@@ -5911,7 +5889,7 @@ static PyObject *__pyx_pw_8st_utils_5update_pixel_map_search(PyObject *__pyx_sel
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "update_pixel_map_search") < 0)) __PYX_ERR(0, 202, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "update_pixel_map") < 0)) __PYX_ERR(0, 201, __pyx_L3_error)
       }
     } else {
       switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -5931,41 +5909,41 @@ static PyObject *__pyx_pw_8st_utils_5update_pixel_map_search(PyObject *__pyx_sel
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_I_n = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I_n.memview)) __PYX_ERR(0, 202, __pyx_L3_error)
-    __pyx_v_W = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_W.memview)) __PYX_ERR(0, 202, __pyx_L3_error)
-    __pyx_v_I0 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I0.memview)) __PYX_ERR(0, 202, __pyx_L3_error)
-    __pyx_v_u0 = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_u0.memview)) __PYX_ERR(0, 203, __pyx_L3_error)
-    __pyx_v_di = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[4], PyBUF_WRITABLE); if (unlikely(!__pyx_v_di.memview)) __PYX_ERR(0, 203, __pyx_L3_error)
-    __pyx_v_dj = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[5], PyBUF_WRITABLE); if (unlikely(!__pyx_v_dj.memview)) __PYX_ERR(0, 203, __pyx_L3_error)
-    __pyx_v_dss = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_dss == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
-    __pyx_v_dfs = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_dfs == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
+    __pyx_v_I_n = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I_n.memview)) __PYX_ERR(0, 201, __pyx_L3_error)
+    __pyx_v_W = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_W.memview)) __PYX_ERR(0, 201, __pyx_L3_error)
+    __pyx_v_I0 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I0.memview)) __PYX_ERR(0, 201, __pyx_L3_error)
+    __pyx_v_u0 = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_u0.memview)) __PYX_ERR(0, 202, __pyx_L3_error)
+    __pyx_v_di = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[4], PyBUF_WRITABLE); if (unlikely(!__pyx_v_di.memview)) __PYX_ERR(0, 202, __pyx_L3_error)
+    __pyx_v_dj = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[5], PyBUF_WRITABLE); if (unlikely(!__pyx_v_dj.memview)) __PYX_ERR(0, 202, __pyx_L3_error)
+    __pyx_v_dss = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_dss == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L3_error)
+    __pyx_v_dfs = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_dfs == ((npy_float64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L3_error)
     if (values[8]) {
-      __pyx_v_wss = __Pyx_PyInt_As_npy_uint64(values[8]); if (unlikely((__pyx_v_wss == ((npy_uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
+      __pyx_v_wss = __Pyx_PyInt_As_npy_uint64(values[8]); if (unlikely((__pyx_v_wss == ((npy_uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L3_error)
     } else {
       __pyx_v_wss = ((__pyx_t_8st_utils_uint_t)((__pyx_t_8st_utils_uint_t)1));
     }
     if (values[9]) {
-      __pyx_v_wfs = __Pyx_PyInt_As_npy_uint64(values[9]); if (unlikely((__pyx_v_wfs == ((npy_uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
+      __pyx_v_wfs = __Pyx_PyInt_As_npy_uint64(values[9]); if (unlikely((__pyx_v_wfs == ((npy_uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L3_error)
     } else {
       __pyx_v_wfs = ((__pyx_t_8st_utils_uint_t)((__pyx_t_8st_utils_uint_t)0x64));
     }
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("update_pixel_map_search", 0, 8, 10, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 202, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("update_pixel_map", 0, 8, 10, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 201, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("st_utils.update_pixel_map_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("st_utils.update_pixel_map", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_8st_utils_4update_pixel_map_search(__pyx_self, __pyx_v_I_n, __pyx_v_W, __pyx_v_I0, __pyx_v_u0, __pyx_v_di, __pyx_v_dj, __pyx_v_dss, __pyx_v_dfs, __pyx_v_wss, __pyx_v_wfs);
+  __pyx_r = __pyx_pf_8st_utils_4update_pixel_map(__pyx_self, __pyx_v_I_n, __pyx_v_W, __pyx_v_I0, __pyx_v_u0, __pyx_v_di, __pyx_v_dj, __pyx_v_dss, __pyx_v_dfs, __pyx_v_wss, __pyx_v_wfs);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_8st_utils_4update_pixel_map_search(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_I_n, __Pyx_memviewslice __pyx_v_W, __Pyx_memviewslice __pyx_v_I0, __Pyx_memviewslice __pyx_v_u0, __Pyx_memviewslice __pyx_v_di, __Pyx_memviewslice __pyx_v_dj, __pyx_t_8st_utils_float_t __pyx_v_dss, __pyx_t_8st_utils_float_t __pyx_v_dfs, __pyx_t_8st_utils_uint_t __pyx_v_wss, __pyx_t_8st_utils_uint_t __pyx_v_wfs) {
+static PyObject *__pyx_pf_8st_utils_4update_pixel_map(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_I_n, __Pyx_memviewslice __pyx_v_W, __Pyx_memviewslice __pyx_v_I0, __Pyx_memviewslice __pyx_v_u0, __Pyx_memviewslice __pyx_v_di, __Pyx_memviewslice __pyx_v_dj, __pyx_t_8st_utils_float_t __pyx_v_dss, __pyx_t_8st_utils_float_t __pyx_v_dfs, __pyx_t_8st_utils_uint_t __pyx_v_wss, __pyx_t_8st_utils_uint_t __pyx_v_wfs) {
   __pyx_t_8st_utils_int_t __pyx_v_a;
   __pyx_t_8st_utils_int_t __pyx_v_b;
   __pyx_t_8st_utils_int_t __pyx_v_c;
@@ -6029,9 +6007,9 @@ static PyObject *__pyx_pf_8st_utils_4update_pixel_map_search(CYTHON_UNUSED PyObj
   __Pyx_memviewslice __pyx_t_43 = { 0, 0, { 0 }, { 0 }, { 0 } };
   __pyx_t_8st_utils_int_t __pyx_t_44;
   __pyx_t_8st_utils_int_t __pyx_t_45;
-  __Pyx_RefNannySetupContext("update_pixel_map_search", 0);
+  __Pyx_RefNannySetupContext("update_pixel_map", 0);
 
-  /* "st_utils.pyx":217
+  /* "st_utils.pyx":216
  *     """
  *     cdef:
  *         int_t a = I_n.shape[0], b = I_n.shape[1], c = I_n.shape[2], j, k             # <<<<<<<<<<<<<<
@@ -6042,7 +6020,7 @@ static PyObject *__pyx_pf_8st_utils_4update_pixel_map_search(CYTHON_UNUSED PyObj
   __pyx_v_b = (__pyx_v_I_n.shape[1]);
   __pyx_v_c = (__pyx_v_I_n.shape[2]);
 
-  /* "st_utils.pyx":218
+  /* "st_utils.pyx":217
  *     cdef:
  *         int_t a = I_n.shape[0], b = I_n.shape[1], c = I_n.shape[2], j, k
  *         int_t aa = I0.shape[0], bb = I0.shape[1]             # <<<<<<<<<<<<<<
@@ -6052,7 +6030,7 @@ static PyObject *__pyx_pf_8st_utils_4update_pixel_map_search(CYTHON_UNUSED PyObj
   __pyx_v_aa = (__pyx_v_I0.shape[0]);
   __pyx_v_bb = (__pyx_v_I0.shape[1]);
 
-  /* "st_utils.pyx":219
+  /* "st_utils.pyx":218
  *         int_t a = I_n.shape[0], b = I_n.shape[1], c = I_n.shape[2], j, k
  *         int_t aa = I0.shape[0], bb = I0.shape[1]
  *         float_t di0 = min_float(&di[0], a), di1 = max_float(&di[0], a)             # <<<<<<<<<<<<<<
@@ -6064,7 +6042,7 @@ static PyObject *__pyx_pf_8st_utils_4update_pixel_map_search(CYTHON_UNUSED PyObj
   __pyx_t_2 = 0;
   __pyx_v_di1 = __pyx_f_8st_utils_max_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_di.data) + __pyx_t_2)) )))), __pyx_v_a);
 
-  /* "st_utils.pyx":220
+  /* "st_utils.pyx":219
  *         int_t aa = I0.shape[0], bb = I0.shape[1]
  *         float_t di0 = min_float(&di[0], a), di1 = max_float(&di[0], a)
  *         float_t dj0 = min_float(&dj[0], a), dj1 = max_float(&dj[0], a)             # <<<<<<<<<<<<<<
@@ -6076,23 +6054,23 @@ static PyObject *__pyx_pf_8st_utils_4update_pixel_map_search(CYTHON_UNUSED PyObj
   __pyx_t_4 = 0;
   __pyx_v_dj1 = __pyx_f_8st_utils_max_float((&(*((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ ((char *) (((__pyx_t_8st_utils_float_t *) __pyx_v_dj.data) + __pyx_t_4)) )))), __pyx_v_a);
 
-  /* "st_utils.pyx":222
+  /* "st_utils.pyx":221
  *         float_t dj0 = min_float(&dj[0], a), dj1 = max_float(&dj[0], a)
  *         float_t i0, i1, j0, j1
  *         float_t[:, :, ::1] u = np.empty((2, b, c), dtype=np.float64)             # <<<<<<<<<<<<<<
  *     u[...] = u0
- *     for j in range(b):
+ *     for j in prange(b, schedule='guided', nogil=True):
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_6);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyInt_From_npy_int64(__pyx_v_b); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_7 = __Pyx_PyInt_From_npy_int64(__pyx_v_c); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyInt_From_npy_int64(__pyx_v_c); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
-  __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
   __Pyx_INCREF(__pyx_int_2);
   __Pyx_GIVEREF(__pyx_int_2);
@@ -6103,214 +6081,379 @@ static PyObject *__pyx_pf_8st_utils_4update_pixel_map_search(CYTHON_UNUSED PyObj
   PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7);
   __pyx_t_5 = 0;
   __pyx_t_7 = 0;
-  __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
   __Pyx_GIVEREF(__pyx_t_8);
   PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8);
   __pyx_t_8 = 0;
-  __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
-  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float64); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float64); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(0, 222, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-  __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
   __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
   __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
   __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(__pyx_t_9, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   __pyx_v_u = __pyx_t_10;
   __pyx_t_10.memview = NULL;
   __pyx_t_10.data = NULL;
 
-  /* "st_utils.pyx":223
+  /* "st_utils.pyx":222
  *         float_t i0, i1, j0, j1
  *         float_t[:, :, ::1] u = np.empty((2, b, c), dtype=np.float64)
  *     u[...] = u0             # <<<<<<<<<<<<<<
- *     for j in range(b):
+ *     for j in prange(b, schedule='guided', nogil=True):
  *         for k in range(c):
  */
-  if (unlikely(__pyx_memoryview_copy_contents(__pyx_v_u0, __pyx_v_u, 3, 3, 0) < 0)) __PYX_ERR(0, 223, __pyx_L1_error)
+  if (unlikely(__pyx_memoryview_copy_contents(__pyx_v_u0, __pyx_v_u, 3, 3, 0) < 0)) __PYX_ERR(0, 222, __pyx_L1_error)
 
-  /* "st_utils.pyx":224
+  /* "st_utils.pyx":223
  *         float_t[:, :, ::1] u = np.empty((2, b, c), dtype=np.float64)
  *     u[...] = u0
- *     for j in range(b):             # <<<<<<<<<<<<<<
+ *     for j in prange(b, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
  *         for k in range(c):
  *             # Define window search bounds
  */
-  __pyx_t_11 = __pyx_v_b;
-  __pyx_t_12 = __pyx_t_11;
-  for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) {
-    __pyx_v_j = __pyx_t_13;
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      __Pyx_FastGIL_Remember();
+      #endif
+      /*try:*/ {
+        __pyx_t_11 = __pyx_v_b;
+        if ((1 == 0)) abort();
+        {
+            __pyx_t_8st_utils_float_t __pyx_parallel_temp0 = ((__pyx_t_8st_utils_float_t)__PYX_NAN());
+            __pyx_t_8st_utils_float_t __pyx_parallel_temp1 = ((__pyx_t_8st_utils_float_t)__PYX_NAN());
+            __pyx_t_8st_utils_int_t __pyx_parallel_temp2 = ((__pyx_t_8st_utils_int_t)0xbad0bad0);
+            __pyx_t_8st_utils_float_t __pyx_parallel_temp3 = ((__pyx_t_8st_utils_float_t)__PYX_NAN());
+            __pyx_t_8st_utils_float_t __pyx_parallel_temp4 = ((__pyx_t_8st_utils_float_t)__PYX_NAN());
+            __pyx_t_8st_utils_int_t __pyx_parallel_temp5 = ((__pyx_t_8st_utils_int_t)0xbad0bad0);
+            const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0;
+            PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL;
+            int __pyx_parallel_why;
+            __pyx_parallel_why = 0;
+            #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
+                #undef likely
+                #undef unlikely
+                #define likely(x)   (x)
+                #define unlikely(x) (x)
+            #endif
+            __pyx_t_13 = (__pyx_t_11 - 0 + 1 - 1/abs(1)) / 1;
+            if (__pyx_t_13 > 0)
+            {
+                #ifdef _OPENMP
+                #pragma omp parallel private(__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_t_25, __pyx_t_26, __pyx_t_27, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_t_31, __pyx_t_32, __pyx_t_33, __pyx_t_34, __pyx_t_35, __pyx_t_36, __pyx_t_37, __pyx_t_38, __pyx_t_39, __pyx_t_40, __pyx_t_41, __pyx_t_44, __pyx_t_45) firstprivate(__pyx_t_42, __pyx_t_43) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb)
+                #endif /* _OPENMP */
+                {
+                    #ifdef _OPENMP
+                    #ifdef WITH_THREAD
+                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+                    #endif
+                    Py_BEGIN_ALLOW_THREADS
+                    #endif /* _OPENMP */
+                    #ifdef _OPENMP
+                    #pragma omp for lastprivate(__pyx_v_i0) lastprivate(__pyx_v_i1) firstprivate(__pyx_v_j) lastprivate(__pyx_v_j) lastprivate(__pyx_v_j0) lastprivate(__pyx_v_j1) lastprivate(__pyx_v_k) schedule(guided)
+                    #endif /* _OPENMP */
+                    for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_13; __pyx_t_12++){
+                        if (__pyx_parallel_why < 2)
+                        {
+                            __pyx_v_j = (__pyx_t_8st_utils_int_t)(0 + 1 * __pyx_t_12);
+                            /* Initialize private variables to invalid values */
+                            __pyx_v_i0 = ((__pyx_t_8st_utils_float_t)__PYX_NAN());
+                            __pyx_v_i1 = ((__pyx_t_8st_utils_float_t)__PYX_NAN());
+                            __pyx_v_j0 = ((__pyx_t_8st_utils_float_t)__PYX_NAN());
+                            __pyx_v_j1 = ((__pyx_t_8st_utils_float_t)__PYX_NAN());
+                            __pyx_v_k = ((__pyx_t_8st_utils_int_t)0xbad0bad0);
 
-    /* "st_utils.pyx":225
+                            /* "st_utils.pyx":224
  *     u[...] = u0
- *     for j in range(b):
+ *     for j in prange(b, schedule='guided', nogil=True):
  *         for k in range(c):             # <<<<<<<<<<<<<<
  *             # Define window search bounds
  *             i0 = -<float_t>(wss) if wss < u[0, j, k] - di0 else di0 - u[0, j, k]
  */
-    __pyx_t_14 = __pyx_v_c;
-    __pyx_t_15 = __pyx_t_14;
-    for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) {
-      __pyx_v_k = __pyx_t_16;
+                            __pyx_t_14 = __pyx_v_c;
+                            __pyx_t_15 = __pyx_t_14;
+                            for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) {
+                              __pyx_v_k = __pyx_t_16;
 
-      /* "st_utils.pyx":227
+                              /* "st_utils.pyx":226
  *         for k in range(c):
  *             # Define window search bounds
  *             i0 = -<float_t>(wss) if wss < u[0, j, k] - di0 else di0 - u[0, j, k]             # <<<<<<<<<<<<<<
  *             i1 = <float_t>(wss) if wss < di1 - u[0, j, k] + aa else di1 - u[0, j, k] + aa
  *             j0 = -<float_t>(wfs) if wfs < u[1, j, k] - dj0 else dj0 - u[1, j, k]
  */
-      __pyx_t_18 = 0;
-      __pyx_t_19 = __pyx_v_j;
-      __pyx_t_20 = __pyx_v_k;
-      if (((__pyx_v_wss < ((*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_18 * __pyx_v_u.strides[0]) ) + __pyx_t_19 * __pyx_v_u.strides[1]) )) + __pyx_t_20)) ))) - __pyx_v_di0)) != 0)) {
-        __pyx_t_17 = (-((__pyx_t_8st_utils_float_t)__pyx_v_wss));
-      } else {
-        __pyx_t_21 = 0;
-        __pyx_t_22 = __pyx_v_j;
-        __pyx_t_23 = __pyx_v_k;
-        __pyx_t_17 = (__pyx_v_di0 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_21 * __pyx_v_u.strides[0]) ) + __pyx_t_22 * __pyx_v_u.strides[1]) )) + __pyx_t_23)) ))));
-      }
-      __pyx_v_i0 = __pyx_t_17;
+                              __pyx_t_18 = 0;
+                              __pyx_t_19 = __pyx_v_j;
+                              __pyx_t_20 = __pyx_v_k;
+                              if (((__pyx_v_wss < ((*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_18 * __pyx_v_u.strides[0]) ) + __pyx_t_19 * __pyx_v_u.strides[1]) )) + __pyx_t_20)) ))) - __pyx_v_di0)) != 0)) {
+                                __pyx_t_17 = (-((__pyx_t_8st_utils_float_t)__pyx_v_wss));
+                              } else {
+                                __pyx_t_21 = 0;
+                                __pyx_t_22 = __pyx_v_j;
+                                __pyx_t_23 = __pyx_v_k;
+                                __pyx_t_17 = (__pyx_v_di0 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_21 * __pyx_v_u.strides[0]) ) + __pyx_t_22 * __pyx_v_u.strides[1]) )) + __pyx_t_23)) ))));
+                              }
+                              __pyx_v_i0 = __pyx_t_17;
 
-      /* "st_utils.pyx":228
+                              /* "st_utils.pyx":227
  *             # Define window search bounds
  *             i0 = -<float_t>(wss) if wss < u[0, j, k] - di0 else di0 - u[0, j, k]
  *             i1 = <float_t>(wss) if wss < di1 - u[0, j, k] + aa else di1 - u[0, j, k] + aa             # <<<<<<<<<<<<<<
  *             j0 = -<float_t>(wfs) if wfs < u[1, j, k] - dj0 else dj0 - u[1, j, k]
  *             j1 = <float_t>(wfs) if wfs < dj1 - u[1, j, k] + bb else dj1 - u[1, j, k] + bb
  */
-      __pyx_t_24 = 0;
-      __pyx_t_25 = __pyx_v_j;
-      __pyx_t_26 = __pyx_v_k;
-      if (((__pyx_v_wss < ((__pyx_v_di1 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_24 * __pyx_v_u.strides[0]) ) + __pyx_t_25 * __pyx_v_u.strides[1]) )) + __pyx_t_26)) )))) + __pyx_v_aa)) != 0)) {
-        __pyx_t_17 = ((__pyx_t_8st_utils_float_t)__pyx_v_wss);
-      } else {
-        __pyx_t_27 = 0;
-        __pyx_t_28 = __pyx_v_j;
-        __pyx_t_29 = __pyx_v_k;
-        __pyx_t_17 = ((__pyx_v_di1 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_27 * __pyx_v_u.strides[0]) ) + __pyx_t_28 * __pyx_v_u.strides[1]) )) + __pyx_t_29)) )))) + __pyx_v_aa);
-      }
-      __pyx_v_i1 = __pyx_t_17;
+                              __pyx_t_24 = 0;
+                              __pyx_t_25 = __pyx_v_j;
+                              __pyx_t_26 = __pyx_v_k;
+                              if (((__pyx_v_wss < ((__pyx_v_di1 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_24 * __pyx_v_u.strides[0]) ) + __pyx_t_25 * __pyx_v_u.strides[1]) )) + __pyx_t_26)) )))) + __pyx_v_aa)) != 0)) {
+                                __pyx_t_17 = ((__pyx_t_8st_utils_float_t)__pyx_v_wss);
+                              } else {
+                                __pyx_t_27 = 0;
+                                __pyx_t_28 = __pyx_v_j;
+                                __pyx_t_29 = __pyx_v_k;
+                                __pyx_t_17 = ((__pyx_v_di1 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_27 * __pyx_v_u.strides[0]) ) + __pyx_t_28 * __pyx_v_u.strides[1]) )) + __pyx_t_29)) )))) + __pyx_v_aa);
+                              }
+                              __pyx_v_i1 = __pyx_t_17;
 
-      /* "st_utils.pyx":229
+                              /* "st_utils.pyx":228
  *             i0 = -<float_t>(wss) if wss < u[0, j, k] - di0 else di0 - u[0, j, k]
  *             i1 = <float_t>(wss) if wss < di1 - u[0, j, k] + aa else di1 - u[0, j, k] + aa
  *             j0 = -<float_t>(wfs) if wfs < u[1, j, k] - dj0 else dj0 - u[1, j, k]             # <<<<<<<<<<<<<<
  *             j1 = <float_t>(wfs) if wfs < dj1 - u[1, j, k] + bb else dj1 - u[1, j, k] + bb
  * 
  */
-      __pyx_t_30 = 1;
-      __pyx_t_31 = __pyx_v_j;
-      __pyx_t_32 = __pyx_v_k;
-      if (((__pyx_v_wfs < ((*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_30 * __pyx_v_u.strides[0]) ) + __pyx_t_31 * __pyx_v_u.strides[1]) )) + __pyx_t_32)) ))) - __pyx_v_dj0)) != 0)) {
-        __pyx_t_17 = (-((__pyx_t_8st_utils_float_t)__pyx_v_wfs));
-      } else {
-        __pyx_t_33 = 1;
-        __pyx_t_34 = __pyx_v_j;
-        __pyx_t_35 = __pyx_v_k;
-        __pyx_t_17 = (__pyx_v_dj0 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_33 * __pyx_v_u.strides[0]) ) + __pyx_t_34 * __pyx_v_u.strides[1]) )) + __pyx_t_35)) ))));
-      }
-      __pyx_v_j0 = __pyx_t_17;
+                              __pyx_t_30 = 1;
+                              __pyx_t_31 = __pyx_v_j;
+                              __pyx_t_32 = __pyx_v_k;
+                              if (((__pyx_v_wfs < ((*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_30 * __pyx_v_u.strides[0]) ) + __pyx_t_31 * __pyx_v_u.strides[1]) )) + __pyx_t_32)) ))) - __pyx_v_dj0)) != 0)) {
+                                __pyx_t_17 = (-((__pyx_t_8st_utils_float_t)__pyx_v_wfs));
+                              } else {
+                                __pyx_t_33 = 1;
+                                __pyx_t_34 = __pyx_v_j;
+                                __pyx_t_35 = __pyx_v_k;
+                                __pyx_t_17 = (__pyx_v_dj0 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_33 * __pyx_v_u.strides[0]) ) + __pyx_t_34 * __pyx_v_u.strides[1]) )) + __pyx_t_35)) ))));
+                              }
+                              __pyx_v_j0 = __pyx_t_17;
 
-      /* "st_utils.pyx":230
+                              /* "st_utils.pyx":229
  *             i1 = <float_t>(wss) if wss < di1 - u[0, j, k] + aa else di1 - u[0, j, k] + aa
  *             j0 = -<float_t>(wfs) if wfs < u[1, j, k] - dj0 else dj0 - u[1, j, k]
  *             j1 = <float_t>(wfs) if wfs < dj1 - u[1, j, k] + bb else dj1 - u[1, j, k] + bb             # <<<<<<<<<<<<<<
  * 
  *             # Execute pixel map search
  */
-      __pyx_t_36 = 1;
-      __pyx_t_37 = __pyx_v_j;
-      __pyx_t_38 = __pyx_v_k;
-      if (((__pyx_v_wfs < ((__pyx_v_dj1 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_36 * __pyx_v_u.strides[0]) ) + __pyx_t_37 * __pyx_v_u.strides[1]) )) + __pyx_t_38)) )))) + __pyx_v_bb)) != 0)) {
-        __pyx_t_17 = ((__pyx_t_8st_utils_float_t)__pyx_v_wfs);
-      } else {
-        __pyx_t_39 = 1;
-        __pyx_t_40 = __pyx_v_j;
-        __pyx_t_41 = __pyx_v_k;
-        __pyx_t_17 = ((__pyx_v_dj1 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_39 * __pyx_v_u.strides[0]) ) + __pyx_t_40 * __pyx_v_u.strides[1]) )) + __pyx_t_41)) )))) + __pyx_v_bb);
-      }
-      __pyx_v_j1 = __pyx_t_17;
+                              __pyx_t_36 = 1;
+                              __pyx_t_37 = __pyx_v_j;
+                              __pyx_t_38 = __pyx_v_k;
+                              if (((__pyx_v_wfs < ((__pyx_v_dj1 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_36 * __pyx_v_u.strides[0]) ) + __pyx_t_37 * __pyx_v_u.strides[1]) )) + __pyx_t_38)) )))) + __pyx_v_bb)) != 0)) {
+                                __pyx_t_17 = ((__pyx_t_8st_utils_float_t)__pyx_v_wfs);
+                              } else {
+                                __pyx_t_39 = 1;
+                                __pyx_t_40 = __pyx_v_j;
+                                __pyx_t_41 = __pyx_v_k;
+                                __pyx_t_17 = ((__pyx_v_dj1 - (*((__pyx_t_8st_utils_float_t *) ( /* dim=2 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_u.data + __pyx_t_39 * __pyx_v_u.strides[0]) ) + __pyx_t_40 * __pyx_v_u.strides[1]) )) + __pyx_t_41)) )))) + __pyx_v_bb);
+                              }
+                              __pyx_v_j1 = __pyx_t_17;
 
-      /* "st_utils.pyx":233
+                              /* "st_utils.pyx":232
  * 
  *             # Execute pixel map search
  *             search_2d(I_n[:, j, k], I0, di, dj, u[:, j, k], W[j, k],             # <<<<<<<<<<<<<<
  *                       <int_t>(i0), <int_t>(i1), <int_t>(j0), <int_t>(j1), dss, dfs)
  *     return np.asarray(u)
  */
-      __pyx_t_42.data = __pyx_v_I_n.data;
-      __pyx_t_42.memview = __pyx_v_I_n.memview;
-      __PYX_INC_MEMVIEW(&__pyx_t_42, 0);
-      __pyx_t_42.shape[0] = __pyx_v_I_n.shape[0];
+                              __pyx_t_42.data = __pyx_v_I_n.data;
+                              __pyx_t_42.memview = __pyx_v_I_n.memview;
+                              __PYX_INC_MEMVIEW(&__pyx_t_42, 0);
+                              __pyx_t_42.shape[0] = __pyx_v_I_n.shape[0];
 __pyx_t_42.strides[0] = __pyx_v_I_n.strides[0];
     __pyx_t_42.suboffsets[0] = -1;
 
 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_j;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_I_n.strides[1];
-        if ((0)) __PYX_ERR(0, 233, __pyx_L1_error)
+        if ((0)) __PYX_ERR(0, 232, __pyx_L8_error)
         __pyx_t_42.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_k;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_I_n.strides[2];
-        if ((0)) __PYX_ERR(0, 233, __pyx_L1_error)
+        if ((0)) __PYX_ERR(0, 232, __pyx_L8_error)
         __pyx_t_42.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
 __pyx_t_43.data = __pyx_v_u.data;
-      __pyx_t_43.memview = __pyx_v_u.memview;
-      __PYX_INC_MEMVIEW(&__pyx_t_43, 0);
-      __pyx_t_43.shape[0] = __pyx_v_u.shape[0];
+                              __pyx_t_43.memview = __pyx_v_u.memview;
+                              __PYX_INC_MEMVIEW(&__pyx_t_43, 0);
+                              __pyx_t_43.shape[0] = __pyx_v_u.shape[0];
 __pyx_t_43.strides[0] = __pyx_v_u.strides[0];
     __pyx_t_43.suboffsets[0] = -1;
 
 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_j;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_u.strides[1];
-        if ((0)) __PYX_ERR(0, 233, __pyx_L1_error)
+        if ((0)) __PYX_ERR(0, 232, __pyx_L8_error)
         __pyx_t_43.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_k;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_u.strides[2];
-        if ((0)) __PYX_ERR(0, 233, __pyx_L1_error)
+        if ((0)) __PYX_ERR(0, 232, __pyx_L8_error)
         __pyx_t_43.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
 __pyx_t_44 = __pyx_v_j;
-      __pyx_t_45 = __pyx_v_k;
+                              __pyx_t_45 = __pyx_v_k;
 
-      /* "st_utils.pyx":234
+                              /* "st_utils.pyx":233
  *             # Execute pixel map search
  *             search_2d(I_n[:, j, k], I0, di, dj, u[:, j, k], W[j, k],
  *                       <int_t>(i0), <int_t>(i1), <int_t>(j0), <int_t>(j1), dss, dfs)             # <<<<<<<<<<<<<<
  *     return np.asarray(u)
  * 
  */
-      __pyx_f_8st_utils_search_2d(__pyx_t_42, __pyx_v_I0, __pyx_v_di, __pyx_v_dj, __pyx_t_43, (*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_W.data + __pyx_t_44 * __pyx_v_W.strides[0]) )) + __pyx_t_45)) ))), ((__pyx_t_8st_utils_int_t)__pyx_v_i0), ((__pyx_t_8st_utils_int_t)__pyx_v_i1), ((__pyx_t_8st_utils_int_t)__pyx_v_j0), ((__pyx_t_8st_utils_int_t)__pyx_v_j1), __pyx_v_dss, __pyx_v_dfs);
-      __PYX_XDEC_MEMVIEW(&__pyx_t_42, 1);
-      __pyx_t_42.memview = NULL;
-      __pyx_t_42.data = NULL;
-      __PYX_XDEC_MEMVIEW(&__pyx_t_43, 1);
-      __pyx_t_43.memview = NULL;
-      __pyx_t_43.data = NULL;
-    }
+                              __pyx_f_8st_utils_search_2d(__pyx_t_42, __pyx_v_I0, __pyx_v_di, __pyx_v_dj, __pyx_t_43, (*((__pyx_t_8st_utils_float_t *) ( /* dim=1 */ ((char *) (((__pyx_t_8st_utils_float_t *) ( /* dim=0 */ (__pyx_v_W.data + __pyx_t_44 * __pyx_v_W.strides[0]) )) + __pyx_t_45)) ))), ((__pyx_t_8st_utils_int_t)__pyx_v_i0), ((__pyx_t_8st_utils_int_t)__pyx_v_i1), ((__pyx_t_8st_utils_int_t)__pyx_v_j0), ((__pyx_t_8st_utils_int_t)__pyx_v_j1), __pyx_v_dss, __pyx_v_dfs);
+                              __PYX_XDEC_MEMVIEW(&__pyx_t_42, 0);
+                              __pyx_t_42.memview = NULL;
+                              __pyx_t_42.data = NULL;
+                              __PYX_XDEC_MEMVIEW(&__pyx_t_43, 0);
+                              __pyx_t_43.memview = NULL;
+                              __pyx_t_43.data = NULL;
+                            }
+                            goto __pyx_L13;
+                            __pyx_L8_error:;
+                            {
+                                #ifdef WITH_THREAD
+                                PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+                                #endif
+                                #ifdef _OPENMP
+                                #pragma omp flush(__pyx_parallel_exc_type)
+                                #endif /* _OPENMP */
+                                if (!__pyx_parallel_exc_type) {
+                                  __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb);
+                                  __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno;
+                                  __Pyx_GOTREF(__pyx_parallel_exc_type);
+                                }
+                                #ifdef WITH_THREAD
+                                __Pyx_PyGILState_Release(__pyx_gilstate_save);
+                                #endif
+                            }
+                            __pyx_parallel_why = 4;
+                            goto __pyx_L12;
+                            __pyx_L12:;
+                            #ifdef _OPENMP
+                            #pragma omp critical(__pyx_parallel_lastprivates1)
+                            #endif /* _OPENMP */
+                            {
+                                __pyx_parallel_temp0 = __pyx_v_i0;
+                                __pyx_parallel_temp1 = __pyx_v_i1;
+                                __pyx_parallel_temp2 = __pyx_v_j;
+                                __pyx_parallel_temp3 = __pyx_v_j0;
+                                __pyx_parallel_temp4 = __pyx_v_j1;
+                                __pyx_parallel_temp5 = __pyx_v_k;
+                            }
+                            __pyx_L13:;
+                            #ifdef _OPENMP
+                            #pragma omp flush(__pyx_parallel_why)
+                            #endif /* _OPENMP */
+                        }
+                    }
+                    #ifdef _OPENMP
+                    Py_END_ALLOW_THREADS
+                    #else
+{
+#ifdef WITH_THREAD
+                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+                    #endif
+                    #endif /* _OPENMP */
+                    /* Clean up any temporaries */
+                    __PYX_XDEC_MEMVIEW(&__pyx_t_42, 0);
+                    __PYX_XDEC_MEMVIEW(&__pyx_t_43, 0);
+                    #ifdef WITH_THREAD
+                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
+                    #endif
+                    #ifndef _OPENMP
+}
+#endif /* _OPENMP */
+                }
+            }
+            if (__pyx_parallel_exc_type) {
+              /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */
+              __pyx_parallel_why = 4;
+            }
+            if (__pyx_parallel_why) {
+              __pyx_v_i0 = __pyx_parallel_temp0;
+              __pyx_v_i1 = __pyx_parallel_temp1;
+              __pyx_v_j = __pyx_parallel_temp2;
+              __pyx_v_j0 = __pyx_parallel_temp3;
+              __pyx_v_j1 = __pyx_parallel_temp4;
+              __pyx_v_k = __pyx_parallel_temp5;
+              switch (__pyx_parallel_why) {
+                    case 4:
+                {
+                    #ifdef WITH_THREAD
+                    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+                    #endif
+                    __Pyx_GIVEREF(__pyx_parallel_exc_type);
+                    __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb);
+                    __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno;
+                    #ifdef WITH_THREAD
+                    __Pyx_PyGILState_Release(__pyx_gilstate_save);
+                    #endif
+                }
+                goto __pyx_L4_error;
+              }
+            }
+        }
+        #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))))
+            #undef likely
+            #undef unlikely
+            #define likely(x)   __builtin_expect(!!(x), 1)
+            #define unlikely(x) __builtin_expect(!!(x), 0)
+        #endif
+      }
+
+      /* "st_utils.pyx":223
+ *         float_t[:, :, ::1] u = np.empty((2, b, c), dtype=np.float64)
+ *     u[...] = u0
+ *     for j in prange(b, schedule='guided', nogil=True):             # <<<<<<<<<<<<<<
+ *         for k in range(c):
+ *             # Define window search bounds
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
   }
 
-  /* "st_utils.pyx":235
+  /* "st_utils.pyx":234
  *             search_2d(I_n[:, j, k], I0, di, dj, u[:, j, k], W[j, k],
  *                       <int_t>(i0), <int_t>(i1), <int_t>(j0), <int_t>(j1), dss, dfs)
  *     return np.asarray(u)             # <<<<<<<<<<<<<<
@@ -6318,12 +6461,12 @@ __pyx_t_44 = __pyx_v_j;
  * def total_mse(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 234, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
-  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_asarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_asarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
   __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_u, 3, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float_t, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_u, 3, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_8st_utils_float_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_8st_utils_float_t, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 234, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
   __pyx_t_6 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
@@ -6338,19 +6481,19 @@ __pyx_t_44 = __pyx_v_j;
   __pyx_t_9 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8);
   __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
   __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 235, __pyx_L1_error)
+  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 234, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
   __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
   __pyx_r = __pyx_t_9;
   __pyx_t_9 = 0;
   goto __pyx_L0;
 
-  /* "st_utils.pyx":202
+  /* "st_utils.pyx":201
  *     u[0] += i_min; u[1] += j_min
  * 
- * def update_pixel_map_search(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
- *                             float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
- *                             float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
+ * def update_pixel_map(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
+ *                      float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
+ *                      float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
  */
 
   /* function exit code */
@@ -6363,7 +6506,7 @@ __pyx_t_44 = __pyx_v_j;
   __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
   __PYX_XDEC_MEMVIEW(&__pyx_t_42, 1);
   __PYX_XDEC_MEMVIEW(&__pyx_t_43, 1);
-  __Pyx_AddTraceback("st_utils.update_pixel_map_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("st_utils.update_pixel_map", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __PYX_XDEC_MEMVIEW(&__pyx_v_u, 1);
@@ -6378,7 +6521,7 @@ __pyx_t_44 = __pyx_v_j;
   return __pyx_r;
 }
 
-/* "st_utils.pyx":237
+/* "st_utils.pyx":236
  *     return np.asarray(u)
  * 
  * def total_mse(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
@@ -6431,35 +6574,35 @@ static PyObject *__pyx_pw_8st_utils_7total_mse(PyObject *__pyx_self, PyObject *_
         case  1:
         if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_W)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 1); __PYX_ERR(0, 237, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 1); __PYX_ERR(0, 236, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_I0)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 2); __PYX_ERR(0, 237, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 2); __PYX_ERR(0, 236, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
         if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_u)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 3); __PYX_ERR(0, 237, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 3); __PYX_ERR(0, 236, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
         if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_di)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 4); __PYX_ERR(0, 237, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 4); __PYX_ERR(0, 236, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  5:
         if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dj)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 5); __PYX_ERR(0, 237, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, 5); __PYX_ERR(0, 236, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "total_mse") < 0)) __PYX_ERR(0, 237, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "total_mse") < 0)) __PYX_ERR(0, 236, __pyx_L3_error)
       }
     } else if (PyTuple_GET_SIZE(__pyx_args) != 6) {
       goto __pyx_L5_argtuple_error;
@@ -6471,16 +6614,16 @@ static PyObject *__pyx_pw_8st_utils_7total_mse(PyObject *__pyx_self, PyObject *_
       values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
       values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
     }
-    __pyx_v_I_n = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I_n.memview)) __PYX_ERR(0, 237, __pyx_L3_error)
-    __pyx_v_W = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_W.memview)) __PYX_ERR(0, 237, __pyx_L3_error)
-    __pyx_v_I0 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I0.memview)) __PYX_ERR(0, 237, __pyx_L3_error)
-    __pyx_v_u = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_u.memview)) __PYX_ERR(0, 238, __pyx_L3_error)
-    __pyx_v_di = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[4], PyBUF_WRITABLE); if (unlikely(!__pyx_v_di.memview)) __PYX_ERR(0, 238, __pyx_L3_error)
-    __pyx_v_dj = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[5], PyBUF_WRITABLE); if (unlikely(!__pyx_v_dj.memview)) __PYX_ERR(0, 238, __pyx_L3_error)
+    __pyx_v_I_n = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I_n.memview)) __PYX_ERR(0, 236, __pyx_L3_error)
+    __pyx_v_W = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_W.memview)) __PYX_ERR(0, 236, __pyx_L3_error)
+    __pyx_v_I0 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_I0.memview)) __PYX_ERR(0, 236, __pyx_L3_error)
+    __pyx_v_u = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_u.memview)) __PYX_ERR(0, 237, __pyx_L3_error)
+    __pyx_v_di = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[4], PyBUF_WRITABLE); if (unlikely(!__pyx_v_di.memview)) __PYX_ERR(0, 237, __pyx_L3_error)
+    __pyx_v_dj = __Pyx_PyObject_to_MemoryviewSlice_dc_nn___pyx_t_8st_utils_float_t(values[5], PyBUF_WRITABLE); if (unlikely(!__pyx_v_dj.memview)) __PYX_ERR(0, 237, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 237, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("total_mse", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 236, __pyx_L3_error)
   __pyx_L3_error:;
   __Pyx_AddTraceback("st_utils.total_mse", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
@@ -6519,7 +6662,7 @@ static PyObject *__pyx_pf_8st_utils_6total_mse(CYTHON_UNUSED PyObject *__pyx_sel
   PyObject *__pyx_t_16 = NULL;
   __Pyx_RefNannySetupContext("total_mse", 0);
 
-  /* "st_utils.pyx":249
+  /* "st_utils.pyx":248
  *     """
  *     cdef:
  *         int_t b = I_n.shape[1], c = I_n.shape[2], j, k             # <<<<<<<<<<<<<<
@@ -6529,7 +6672,7 @@ static PyObject *__pyx_pf_8st_utils_6total_mse(CYTHON_UNUSED PyObject *__pyx_sel
   __pyx_v_b = (__pyx_v_I_n.shape[1]);
   __pyx_v_c = (__pyx_v_I_n.shape[2]);
 
-  /* "st_utils.pyx":250
+  /* "st_utils.pyx":249
  *     cdef:
  *         int_t b = I_n.shape[1], c = I_n.shape[2], j, k
  *         float_t err = 0             # <<<<<<<<<<<<<<
@@ -6538,7 +6681,7 @@ static PyObject *__pyx_pf_8st_utils_6total_mse(CYTHON_UNUSED PyObject *__pyx_sel
  */
   __pyx_v_err = 0.0;
 
-  /* "st_utils.pyx":251
+  /* "st_utils.pyx":250
  *         int_t b = I_n.shape[1], c = I_n.shape[2], j, k
  *         float_t err = 0
  *     for j in range(b):             # <<<<<<<<<<<<<<
@@ -6550,7 +6693,7 @@ static PyObject *__pyx_pf_8st_utils_6total_mse(CYTHON_UNUSED PyObject *__pyx_sel
   for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
     __pyx_v_j = __pyx_t_3;
 
-    /* "st_utils.pyx":252
+    /* "st_utils.pyx":251
  *         float_t err = 0
  *     for j in range(b):
  *         for k in range(c):             # <<<<<<<<<<<<<<
@@ -6562,7 +6705,7 @@ static PyObject *__pyx_pf_8st_utils_6total_mse(CYTHON_UNUSED PyObject *__pyx_sel
     for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
       __pyx_v_k = __pyx_t_6;
 
-      /* "st_utils.pyx":253
+      /* "st_utils.pyx":252
  *     for j in range(b):
  *         for k in range(c):
  *             err += mse_bi(I_n[:, j, k], I0, W[j, k], di, dj, u[0, j, k], u[1, j, k])             # <<<<<<<<<<<<<<
@@ -6578,14 +6721,14 @@ __pyx_t_7.strides[0] = __pyx_v_I_n.strides[0];
 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_j;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_I_n.strides[1];
-        if ((0)) __PYX_ERR(0, 253, __pyx_L1_error)
+        if ((0)) __PYX_ERR(0, 252, __pyx_L1_error)
         __pyx_t_7.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
 {
     Py_ssize_t __pyx_tmp_idx = __pyx_v_k;
     Py_ssize_t __pyx_tmp_stride = __pyx_v_I_n.strides[2];
-        if ((0)) __PYX_ERR(0, 253, __pyx_L1_error)
+        if ((0)) __PYX_ERR(0, 252, __pyx_L1_error)
         __pyx_t_7.data += __pyx_tmp_idx * __pyx_tmp_stride;
 }
 
@@ -6604,19 +6747,19 @@ __pyx_t_8 = __pyx_v_j;
     }
   }
 
-  /* "st_utils.pyx":254
+  /* "st_utils.pyx":253
  *         for k in range(c):
  *             err += mse_bi(I_n[:, j, k], I0, W[j, k], di, dj, u[0, j, k], u[1, j, k])
  *     return err / b / c             # <<<<<<<<<<<<<<
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_16 = PyFloat_FromDouble(((__pyx_v_err / ((__pyx_t_8st_utils_float_t)__pyx_v_b)) / ((__pyx_t_8st_utils_float_t)__pyx_v_c))); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 254, __pyx_L1_error)
+  __pyx_t_16 = PyFloat_FromDouble(((__pyx_v_err / ((__pyx_t_8st_utils_float_t)__pyx_v_b)) / ((__pyx_t_8st_utils_float_t)__pyx_v_c))); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 253, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_16);
   __pyx_r = __pyx_t_16;
   __pyx_t_16 = 0;
   goto __pyx_L0;
 
-  /* "st_utils.pyx":237
+  /* "st_utils.pyx":236
  *     return np.asarray(u)
  * 
  * def total_mse(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
@@ -22719,7 +22862,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_err, __pyx_k_err, sizeof(__pyx_k_err), 0, 0, 1, 1},
   {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1},
   {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1},
-  {&__pyx_n_s_float32, __pyx_k_float32, sizeof(__pyx_k_float32), 0, 0, 1, 1},
   {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1},
   {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1},
   {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1},
@@ -22796,7 +22938,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
   {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1},
   {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1},
-  {&__pyx_n_s_update_pixel_map_search, __pyx_k_update_pixel_map_search, sizeof(__pyx_k_update_pixel_map_search), 0, 0, 1, 1},
+  {&__pyx_n_s_update_pixel_map, __pyx_k_update_pixel_map, sizeof(__pyx_k_update_pixel_map), 0, 0, 1, 1},
   {&__pyx_n_s_w0, __pyx_k_w0, sizeof(__pyx_k_w0), 0, 0, 1, 1},
   {&__pyx_n_s_wf, __pyx_k_wf, sizeof(__pyx_k_wf), 0, 0, 1, 1},
   {&__pyx_n_s_wfs, __pyx_k_wfs, sizeof(__pyx_k_wfs), 0, 0, 1, 1},
@@ -22805,7 +22947,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {0, 0, 0, 0, 0, 0, 0}
 };
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 49, __pyx_L1_error)
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 48, __pyx_L1_error)
   __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error)
   __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error)
   __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error)
@@ -23093,53 +23235,53 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_GOTREF(__pyx_tuple__25);
   __Pyx_GIVEREF(__pyx_tuple__25);
 
-  /* "st_utils.pyx":35
+  /* "st_utils.pyx":34
  *     return array[k]
  * 
- * def make_whitefield_st(float32_t[:, :, ::1] data, bool_t[:, ::1] mask):             # <<<<<<<<<<<<<<
+ * def make_whitefield_st(float_t[:, :, ::1] data, bool_t[:, ::1] mask):             # <<<<<<<<<<<<<<
  *     """
  *     Return whitefield based on median filtering of the stack of frames
  */
-  __pyx_tuple__26 = PyTuple_Pack(11, __pyx_n_s_data, __pyx_n_s_mask, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_max_threads, __pyx_n_s_wf, __pyx_n_s_array); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 35, __pyx_L1_error)
+  __pyx_tuple__26 = PyTuple_Pack(11, __pyx_n_s_data, __pyx_n_s_mask, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_max_threads, __pyx_n_s_wf, __pyx_n_s_array); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 34, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__26);
   __Pyx_GIVEREF(__pyx_tuple__26);
-  __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 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_st_utils_pyx, __pyx_n_s_make_whitefield_st, 35, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 35, __pyx_L1_error)
+  __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 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_st_utils_pyx, __pyx_n_s_make_whitefield_st, 34, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 34, __pyx_L1_error)
 
-  /* "st_utils.pyx":100
+  /* "st_utils.pyx":99
  *                     w0[jj, kk] += W[j, k]**2 * rbf(ss - jj, ls) * rbf(fs - kk, ls)
  * 
  * def make_reference(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, :, ::1] u,             # <<<<<<<<<<<<<<
  *                    float_t[::1] di, float_t[::1] dj, float_t ls=2.5):
  *     """
  */
-  __pyx_tuple__28 = PyTuple_Pack(17, __pyx_n_s_I_n, __pyx_n_s_W, __pyx_n_s_u, __pyx_n_s_di, __pyx_n_s_dj, __pyx_n_s_ls, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_n0, __pyx_n_s_m0, __pyx_n_s_aa, __pyx_n_s_bb, __pyx_n_s_I0, __pyx_n_s_w0); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __pyx_tuple__28 = PyTuple_Pack(17, __pyx_n_s_I_n, __pyx_n_s_W, __pyx_n_s_u, __pyx_n_s_di, __pyx_n_s_dj, __pyx_n_s_ls, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_n0, __pyx_n_s_m0, __pyx_n_s_aa, __pyx_n_s_bb, __pyx_n_s_I0, __pyx_n_s_w0); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 99, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__28);
   __Pyx_GIVEREF(__pyx_tuple__28);
-  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(6, 0, 17, 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_st_utils_pyx, __pyx_n_s_make_reference, 100, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(6, 0, 17, 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_st_utils_pyx, __pyx_n_s_make_reference, 99, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 99, __pyx_L1_error)
 
-  /* "st_utils.pyx":202
+  /* "st_utils.pyx":201
  *     u[0] += i_min; u[1] += j_min
  * 
- * def update_pixel_map_search(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
- *                             float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
- *                             float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
+ * def update_pixel_map(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
+ *                      float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
+ *                      float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
  */
-  __pyx_tuple__30 = PyTuple_Pack(26, __pyx_n_s_I_n, __pyx_n_s_W, __pyx_n_s_I0, __pyx_n_s_u0, __pyx_n_s_di, __pyx_n_s_dj, __pyx_n_s_dss, __pyx_n_s_dfs, __pyx_n_s_wss, __pyx_n_s_wfs, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_aa, __pyx_n_s_bb, __pyx_n_s_di0, __pyx_n_s_di1, __pyx_n_s_dj0, __pyx_n_s_dj1, __pyx_n_s_i0, __pyx_n_s_i1, __pyx_n_s_j0, __pyx_n_s_j1, __pyx_n_s_u); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __pyx_tuple__30 = PyTuple_Pack(26, __pyx_n_s_I_n, __pyx_n_s_W, __pyx_n_s_I0, __pyx_n_s_u0, __pyx_n_s_di, __pyx_n_s_dj, __pyx_n_s_dss, __pyx_n_s_dfs, __pyx_n_s_wss, __pyx_n_s_wfs, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_aa, __pyx_n_s_bb, __pyx_n_s_di0, __pyx_n_s_di1, __pyx_n_s_dj0, __pyx_n_s_dj1, __pyx_n_s_i0, __pyx_n_s_i1, __pyx_n_s_j0, __pyx_n_s_j1, __pyx_n_s_u); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 201, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__30);
   __Pyx_GIVEREF(__pyx_tuple__30);
-  __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(10, 0, 26, 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_st_utils_pyx, __pyx_n_s_update_pixel_map_search, 202, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(10, 0, 26, 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_st_utils_pyx, __pyx_n_s_update_pixel_map, 201, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 201, __pyx_L1_error)
 
-  /* "st_utils.pyx":237
+  /* "st_utils.pyx":236
  *     return np.asarray(u)
  * 
  * def total_mse(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
  *               float_t[:, :, ::1] u, float_t[::1] di, float_t[::1] dj):
  *     """
  */
-  __pyx_tuple__32 = PyTuple_Pack(11, __pyx_n_s_I_n, __pyx_n_s_W, __pyx_n_s_I0, __pyx_n_s_u, __pyx_n_s_di, __pyx_n_s_dj, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_err); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 237, __pyx_L1_error)
+  __pyx_tuple__32 = PyTuple_Pack(11, __pyx_n_s_I_n, __pyx_n_s_W, __pyx_n_s_I0, __pyx_n_s_u, __pyx_n_s_di, __pyx_n_s_dj, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_err); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__32);
   __Pyx_GIVEREF(__pyx_tuple__32);
-  __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(6, 0, 11, 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_st_utils_pyx, __pyx_n_s_total_mse, 237, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 237, __pyx_L1_error)
+  __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(6, 0, 11, 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_st_utils_pyx, __pyx_n_s_total_mse, 236, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 236, __pyx_L1_error)
 
   /* "View.MemoryView":286
  *         return self.name
@@ -23594,67 +23736,67 @@ if (!__Pyx_RefNanny) {
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "st_utils.pyx":35
+  /* "st_utils.pyx":34
  *     return array[k]
  * 
- * def make_whitefield_st(float32_t[:, :, ::1] data, bool_t[:, ::1] mask):             # <<<<<<<<<<<<<<
+ * def make_whitefield_st(float_t[:, :, ::1] data, bool_t[:, ::1] mask):             # <<<<<<<<<<<<<<
  *     """
  *     Return whitefield based on median filtering of the stack of frames
  */
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8st_utils_1make_whitefield_st, 0, __pyx_n_s_make_whitefield_st, NULL, __pyx_n_s_st_utils, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8st_utils_1make_whitefield_st, 0, __pyx_n_s_make_whitefield_st, NULL, __pyx_n_s_st_utils, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_whitefield_st, __pyx_t_1) < 0) __PYX_ERR(0, 35, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_whitefield_st, __pyx_t_1) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "st_utils.pyx":101
+  /* "st_utils.pyx":100
  * 
  * def make_reference(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, :, ::1] u,
  *                    float_t[::1] di, float_t[::1] dj, float_t ls=2.5):             # <<<<<<<<<<<<<<
  *     """
  *     Return a reference image
  */
-  __pyx_t_1 = PyFloat_FromDouble(((double)2.5)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(((double)2.5)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 100, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
 
-  /* "st_utils.pyx":100
+  /* "st_utils.pyx":99
  *                     w0[jj, kk] += W[j, k]**2 * rbf(ss - jj, ls) * rbf(fs - kk, ls)
  * 
  * def make_reference(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, :, ::1] u,             # <<<<<<<<<<<<<<
  *                    float_t[::1] di, float_t[::1] dj, float_t ls=2.5):
  *     """
  */
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __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_CyFunction_NewEx(&__pyx_mdef_8st_utils_3make_reference, 0, __pyx_n_s_make_reference, NULL, __pyx_n_s_st_utils, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8st_utils_3make_reference, 0, __pyx_n_s_make_reference, NULL, __pyx_n_s_st_utils, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_t_2);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_reference, __pyx_t_1) < 0) __PYX_ERR(0, 100, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_reference, __pyx_t_1) < 0) __PYX_ERR(0, 99, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "st_utils.pyx":204
- * def update_pixel_map_search(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,
- *                             float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
- *                             float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):             # <<<<<<<<<<<<<<
+  /* "st_utils.pyx":203
+ * def update_pixel_map(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,
+ *                      float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
+ *                      float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):             # <<<<<<<<<<<<<<
  *     """
  *     Update the pixel map
  */
-  __pyx_t_1 = __Pyx_PyInt_From_npy_uint64(((__pyx_t_8st_utils_uint_t)1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_npy_uint64(((__pyx_t_8st_utils_uint_t)1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_From_npy_uint64(((__pyx_t_8st_utils_uint_t)0x64)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_npy_uint64(((__pyx_t_8st_utils_uint_t)0x64)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
 
-  /* "st_utils.pyx":202
+  /* "st_utils.pyx":201
  *     u[0] += i_min; u[1] += j_min
  * 
- * def update_pixel_map_search(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
- *                             float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
- *                             float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
+ * def update_pixel_map(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
+ *                      float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
+ *                      float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
  */
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_1);
   PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
@@ -23662,23 +23804,23 @@ if (!__Pyx_RefNanny) {
   PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
   __pyx_t_1 = 0;
   __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8st_utils_5update_pixel_map_search, 0, __pyx_n_s_update_pixel_map_search, NULL, __pyx_n_s_st_utils, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8st_utils_5update_pixel_map, 0, __pyx_n_s_update_pixel_map, NULL, __pyx_n_s_st_utils, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_update_pixel_map_search, __pyx_t_2) < 0) __PYX_ERR(0, 202, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_update_pixel_map, __pyx_t_2) < 0) __PYX_ERR(0, 201, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "st_utils.pyx":237
+  /* "st_utils.pyx":236
  *     return np.asarray(u)
  * 
  * def total_mse(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,             # <<<<<<<<<<<<<<
  *               float_t[:, :, ::1] u, float_t[::1] di, float_t[::1] dj):
  *     """
  */
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8st_utils_7total_mse, 0, __pyx_n_s_total_mse, NULL, __pyx_n_s_st_utils, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8st_utils_7total_mse, 0, __pyx_n_s_total_mse, NULL, __pyx_n_s_st_utils, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_total_mse, __pyx_t_2) < 0) __PYX_ERR(0, 237, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_total_mse, __pyx_t_2) < 0) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "st_utils.pyx":1
@@ -27493,7 +27635,7 @@ no_fail:
 }
 
 /* ObjectToMemviewSlice */
-  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float32_t(PyObject *obj, int writable_flag) {
+  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(PyObject *obj, int writable_flag) {
     __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
     __Pyx_BufFmt_StackElem stack[1];
     int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) };
@@ -27504,7 +27646,7 @@ no_fail:
     }
     retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG,
                                                  (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 3,
-                                                 &__Pyx_TypeInfo_nn___pyx_t_8st_utils_float32_t, stack,
+                                                 &__Pyx_TypeInfo_nn___pyx_t_8st_utils_float_t, stack,
                                                  &result, obj);
     if (unlikely(retcode == -1))
         goto __pyx_fail;
@@ -27538,29 +27680,6 @@ __pyx_fail:
     return result;
 }
 
-/* ObjectToMemviewSlice */
-  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_nn___pyx_t_8st_utils_float_t(PyObject *obj, int writable_flag) {
-    __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
-    __Pyx_BufFmt_StackElem stack[1];
-    int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) };
-    int retcode;
-    if (obj == Py_None) {
-        result.memview = (struct __pyx_memoryview_obj *) Py_None;
-        return result;
-    }
-    retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG,
-                                                 (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 3,
-                                                 &__Pyx_TypeInfo_nn___pyx_t_8st_utils_float_t, stack,
-                                                 &result, obj);
-    if (unlikely(retcode == -1))
-        goto __pyx_fail;
-    return result;
-__pyx_fail:
-    result.memview = NULL;
-    result.data = NULL;
-    return result;
-}
-
 /* ObjectToMemviewSlice */
   static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float_t(PyObject *obj, int writable_flag) {
     __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
@@ -27691,18 +27810,6 @@ __pyx_fail:
     }
 }
 
-/* MemviewDtypeToObject */
-  static CYTHON_INLINE PyObject *__pyx_memview_get_nn___pyx_t_8st_utils_float32_t(const char *itemp) {
-    return (PyObject *) PyFloat_FromDouble(*(__pyx_t_8st_utils_float32_t *) itemp);
-}
-static CYTHON_INLINE int __pyx_memview_set_nn___pyx_t_8st_utils_float32_t(const char *itemp, PyObject *obj) {
-    __pyx_t_8st_utils_float32_t value = __pyx_PyFloat_AsFloat(obj);
-    if ((value == ((npy_float32)-1)) && PyErr_Occurred())
-        return 0;
-    *(__pyx_t_8st_utils_float32_t *) itemp = value;
-    return 1;
-}
-
 /* MemviewDtypeToObject */
   static CYTHON_INLINE PyObject *__pyx_memview_get_nn___pyx_t_8st_utils_float_t(const char *itemp) {
     return (PyObject *) PyFloat_FromDouble(*(__pyx_t_8st_utils_float_t *) itemp);
@@ -29128,29 +29235,6 @@ raise_neg_overflow:
     return (char) -1;
 }
 
-/* ObjectToMemviewSlice */
-  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_nn___pyx_t_8st_utils_float32_t(PyObject *obj, int writable_flag) {
-    __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
-    __Pyx_BufFmt_StackElem stack[1];
-    int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) };
-    int retcode;
-    if (obj == Py_None) {
-        result.memview = (struct __pyx_memoryview_obj *) Py_None;
-        return result;
-    }
-    retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG,
-                                                 (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 2,
-                                                 &__Pyx_TypeInfo_nn___pyx_t_8st_utils_float32_t, stack,
-                                                 &result, obj);
-    if (unlikely(retcode == -1))
-        goto __pyx_fail;
-    return result;
-__pyx_fail:
-    result.memview = NULL;
-    result.data = NULL;
-    return result;
-}
-
 /* CheckBinaryVersion */
   static int __Pyx_check_binary_version(void) {
     char ctversion[4], rtversion[4];
diff --git a/st_sim/bin/st_utils.pyx b/st_sim/bin/st_utils.pyx
index fd38441..95f4f01 100755
--- a/st_sim/bin/st_utils.pyx
+++ b/st_sim/bin/st_utils.pyx
@@ -7,17 +7,16 @@ cimport openmp
 
 ctypedef cnp.complex128_t complex_t
 ctypedef cnp.float64_t float_t
-ctypedef cnp.float32_t float32_t
 ctypedef cnp.int64_t int_t
 ctypedef cnp.uint64_t uint_t
 ctypedef cnp.uint8_t uint8_t
 ctypedef cnp.npy_bool bool_t
 DEF FLOAT_MAX = 1.7976931348623157e+308
 
-cdef float32_t wirthselect_float(float32_t[:] array, int k) nogil:
+cdef float_t wirthselect_float(float_t[:] array, int k) nogil:
     cdef:
         int_t l = 0, m = array.shape[0] - 1, i, j
-        float32_t x, tmp 
+        float_t x, tmp 
     while l < m: 
         x = array[k] 
         i = l; j = m 
@@ -32,7 +31,7 @@ cdef float32_t wirthselect_float(float32_t[:] array, int k) nogil:
         if k < i: m = j 
     return array[k]
 
-def make_whitefield_st(float32_t[:, :, ::1] data, bool_t[:, ::1] mask):
+def make_whitefield_st(float_t[:, :, ::1] data, bool_t[:, ::1] mask):
     """
     Return whitefield based on median filtering of the stack of frames
 
@@ -42,8 +41,8 @@ def make_whitefield_st(float32_t[:, :, ::1] data, bool_t[:, ::1] mask):
     cdef:
         int_t a = data.shape[0], b = data.shape[1], c = data.shape[2], i, j, k
         int_t max_threads = openmp.omp_get_max_threads()
-        float32_t[:, ::1] wf = np.empty((b, c), dtype=np.float32)
-        float32_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float32)
+        float_t[:, ::1] wf = np.empty((b, c), dtype=np.float64)
+        float_t[:, ::1] array = np.empty((max_threads, a), dtype=np.float64)
     for j in prange(b, schedule='guided', nogil=True):
         i = openmp.omp_get_thread_num()
         for k in range(c):
@@ -199,9 +198,9 @@ cdef void search_2d(float_t[:] I, float_t[:, ::1] I0, float_t[::1] di, float_t[:
                     mse_min = mse; i_min = i; j_min = j
     u[0] += i_min; u[1] += j_min
 
-def update_pixel_map_search(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,
-                            float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
-                            float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
+def update_pixel_map(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:, ::1] I0,
+                     float_t[:, :, ::1] u0, float_t[::1] di, float_t[::1] dj,
+                     float_t dss, float_t dfs, uint_t wss=1, uint_t wfs=100):
     """
     Update the pixel map
 
@@ -221,7 +220,7 @@ def update_pixel_map_search(float_t[:, :, ::1] I_n, float_t[:, ::1] W, float_t[:
         float_t i0, i1, j0, j1
         float_t[:, :, ::1] u = np.empty((2, b, c), dtype=np.float64)
     u[...] = u0
-    for j in range(b):
+    for j in prange(b, schedule='guided', nogil=True):
         for k in range(c):
             # Define window search bounds
             i0 = -<float_t>(wss) if wss < u[0, j, k] - di0 else di0 - u[0, j, k]
diff --git a/st_sim/parameters.ini b/st_sim/parameters.ini
index efe0701..5f9cda6 100755
--- a/st_sim/parameters.ini
+++ b/st_sim/parameters.ini
@@ -19,12 +19,15 @@ ap_x = 40
 ap_y = 2
 focus = 1.5e3
 alpha = -0.05
+x0 = 0.5
 
 [barcode]
 bar_size = 0.1
 bar_sigma = 0.01
-attenuation = 0.3
+bar_atn = 0.3
+bulk_atn = 0.0
 random_dev = 0.6
+offset = 0
 
 [system]
 verbose = False
\ No newline at end of file
diff --git a/st_sim/st_loader.py b/st_sim/st_loader.py
index 3529b98..de954fd 100755
--- a/st_sim/st_loader.py
+++ b/st_sim/st_loader.py
@@ -1,16 +1,19 @@
+from __future__ import division
+
 import os
 import h5py
 import numpy as np
 from scipy.ndimage import gaussian_filter
+from scipy.optimize import least_squares
 from .st_wrapper import cxi_protocol, INIParser, ROOT_PATH
-from .bin import make_whitefield_st, make_reference, update_pixel_map_search, total_mse
+from .bin import make_whitefield_st, make_reference, update_pixel_map, total_mse
 
 class STLoader(INIParser):
     """
     Speckle Tracking scan loader class
     """
     attr_dict = {'paths': ('ALL',)}
-    fmt_dict = {'paths': 'list'}
+    fmt_dict = {'paths': 'str'}
 
     def __init__(self, protocol=cxi_protocol(), **kwargs):
         super(STLoader, self).__init__(**kwargs)
@@ -34,7 +37,7 @@ class STLoader(INIParser):
 
     def load(self, path, defocus=None, roi=None):
         """
-        Load a cxi file and return a STData object
+        Load a cxi file and return a object
         """
         data_dict = {}
         if roi:
@@ -94,11 +97,10 @@ class STData:
     roi - region of interest
     whitefield - whitefield
     """
-    attr_dict = {'basis_vectors', 'data', 'defocus', 'distance',
-                 'translations', 'wavelength', 'x_pixel_size',
-                 'y_pixel_size'}
-    init_dict = {'good_frames', 'mask', 'pixel_translations',
-                 'roi', 'whitefield'}
+    attr_dict = {'basis_vectors', 'data', 'defocus', 'distance', 'translations',
+                 'wavelength', 'x_pixel_size', 'y_pixel_size'}
+    init_dict = {'deviation_angles', 'good_frames', 'mask', 'phase', 'pixel_map',
+                 'pixel_translations', 'reference_image', 'roi', 'whitefield'}
 
     def __init__(self, protocol=cxi_protocol(), **kwargs):
         self.protocol = protocol
@@ -114,12 +116,6 @@ class STData:
             else:
                 raise ValueError('{0:s} has not been provided'.format(attr))
 
-        # Set pixel translations
-        if self.pixel_translations is None:
-            self.pixel_translations = (self.translations[:, None] * self.basis_vectors).sum(axis=-1)
-            self.pixel_translations /= (self.basis_vectors**2).sum(axis=-1) * self.defocus / self.distance
-            self.pixel_translations -= self.pixel_translations.mean(axis=0)
-
         # Set good frames array and mask
         if self.good_frames is None:
             self.good_frames = np.arange(self.data.shape[0])
@@ -128,34 +124,89 @@ class STData:
                                 dtype=self.protocol.dtypes['mask'])
             self.whitefield = make_whitefield_st(data=self.data[self.good_frames], mask=self.mask)
 
+        # Set pixel translations
+        if self.pixel_translations is None:
+            self.pixel_translations = (self.translations[:, None] * self.basis_vectors).sum(axis=-1)
+            self.pixel_translations /= (self.basis_vectors**2).sum(axis=-1) * self.defocus / self.distance
+            self.pixel_translations -= self.pixel_translations.mean(axis=0)
+
+        # Set pixel map, deviation angles, and phase
+        if self.pixel_map is None:
+            self.pixel_map = np.indices(self.whitefield.shape,
+                                        dtype=self.protocol.dtypes['pixel_map'])
+            self.deviation_angles = np.zeros(self.pixel_map.shape,
+                                             dtype=self.protocol.dtypes['deviation_angles'])
+            self.phase = np.zeros(self.whitefield.shape, dtype=self.protocol.dtypes['phase'])
+
+        # Init list of SpeckleTracking1D objects
+        self.st_objects = []
+        SpeckleTracking1D.import_data(self)
+
+    def _update_pixel_map_1d(self, fs_map):
+        fs_idx = np.indices(self.whitefield.shape, dtype=self.protocol.dtypes['pixel_map'])
+        fs_idx = fs_idx[1, self.roi[0]:self.roi[1], self.roi[2]:self.roi[3]]
+        fs_map = np.tile(fs_map, (self.roi[1] - self.roi[0], 1))
+        dev_ang = (fs_map - fs_idx) * self.x_pixel_size / self.distance
+        phase = np.cumsum(dev_ang, axis=1) * self.x_pixel_size * self.defocus / self.distance * 2 * np.pi / self.wavelength
+
+        self.pixel_map[1, self.roi[0]:self.roi[1], self.roi[2]:self.roi[3]] = fs_map
+        self.deviation_angles[1, self.roi[0]:self.roi[1], self.roi[2]:self.roi[3]] = dev_ang
+        self.phase[self.roi[0]: self.roi[1], self.roi[2]:self.roi[3]] = phase
+
     @dict_to_object
     def crop_data(self, roi):
         """
-        Return new STData object with new ROI
+        Return a new object with the updated ROI
         """
         return {'roi': np.asarray(roi, dtype=np.int)}
 
     @dict_to_object
     def mask_frames(self, good_frames):
         """
-        Return new STData object with new good frames mask
+        Return a new object with the updated good frames mask
         """
         return {'good_frames': np.asarray(good_frames, dtype=np.int),
                 'whitefield': make_whitefield_st(data=self.data[good_frames], mask=self.mask)}
 
+    @dict_to_object
+    def make_whitefield(self):
+        """
+        Return a new object with the updated whitefield
+        """
+        return {'whitefield': make_whitefield_st(data=self.data[self.good_frames], mask=self.mask)}
+
     @dict_to_object
     def change_defocus(self, defocus):
         """
-        Return new STData with new defocus distance
+        Return a new object with the updated defocus distance
+        """
+        return {'defocus': defocus}
+
+    def get(self, attr, value=None):
         """
-        return {'defocus': defocus, 'pixel_translations': \
-                self.pixel_translations * self.defocus / defocus}
+        Return the masked data of the given attribute
+        """
+        if attr in self.attr_dict | self.init_dict:
+            data = self.__dict__[attr]
+            if attr in ['data', 'deviation_angles', 'mask', 'phase', 'pixel_map', 'whitefield']:
+                data = data[..., self.roi[0]:self.roi[1], self.roi[2]:self.roi[3]]
+            if attr in ['basis_vectors', 'data', 'pixel_translations', 'translations']:
+                data = data[self.good_frames]
+            return np.ascontiguousarray(data)
+        else:
+            return value
 
-    def st_process(self):
+    def get_st_objects(self):
         """
-        Return a SpeckleTracking1D object
+        Return the list of bound SpeckleTracking1D objects
         """
-        return SpeckleTracking1D.import_dict(**self.__dict__)
+        return self.st_objects
+
+    def get_last_st(self):
+        """
+        Return the last SpeckleTracking1D object
+        """
+        return self.st_objects[-1]
 
 class SpeckleTracking1D:
     """
@@ -167,11 +218,13 @@ class SpeckleTracking1D:
     whitefield - whitefield
     dss_pix, dfs_pix - sample translations along the slow adn fast axes in pixels
     dss_avg, dfs_avg - average sample translation along the slow and fast axes in pixels
-    pix_map - pixel map
-    ref_img - reference image
+    pixel_map - pixel map
+    reference_image - reference image
     """
-    attr_dict = {'roi', 'good_frames', 'data', 'whitefield', 'dss_pix', 'dfs_pix'}
-    init_dict = {'pix_map', 'ref_img', 'dss_avg', 'dfs_avg'}
+    attr_dict = {'data', 'dref', 'defocus', 'dfs_pix', 'dss_pix', 'pixel_map', 'whitefield'}
+    init_dict = {'dfs_avg', 'dss_avg', 'reference_image'}
+    MIN_WFS = 10
+    MAX_DFS = 40
 
     def __init__(self, **kwargs):
         for attr in self.attr_dict | self.init_dict:
@@ -181,22 +234,19 @@ class SpeckleTracking1D:
                 self.__dict__[attr] = None
             else:
                 raise ValueError('{0:s} has not been provided'.format(attr))
-        
+
         if self.dss_avg is None or self.dfs_avg is None:
-            self.dfs_avg = np.mean(self.dfs_pix[1:] - self.dfs_pix[:-1])
-            self.dss_avg = np.mean(self.dss_pix[1:] - self.dss_pix[:-1])
-        if self.pix_map is None:
-            self.pix_map = np.indices(self.whitefield.shape, dtype=np.float64)
-        if self.ref_img is None:
-            self.ref_img, self.dss_pix, self.dfs_pix = \
-            make_reference(I_n=self.data, W=self.whitefield,
-                           u=self.pix_map, di=self.dss_pix,
-                           dj=self.dfs_pix)
+            self.dfs_avg = min(np.mean(np.abs(self.dfs_pix[1:] - self.dfs_pix[:-1])), self.MAX_DFS)
+            self.dss_avg = np.mean(np.abs(self.dss_pix[1:] - self.dss_pix[:-1]))
+        if self.reference_image is None:
+            self.update_reference.inplace_update()
+
+        self.dref.st_objects.append(self)
 
     @classmethod
-    def import_dict(cls, **kwargs):
+    def import_data(cls, st_data):
         """
-        Return a SpeckleTracking object from a data dictionary with the given items:
+        Return a new object from a data dictionary with the given items:
 
         roi - Region Of Interest
         good_frames - array with good frames indexes
@@ -205,40 +255,12 @@ class SpeckleTracking1D:
         whitefield - whitefield
         pixel_translations - sample translations in pixels
         """
-        # fetch the data
-        roi, good_frames = kwargs['roi'], kwargs['good_frames']
-        dct = {'roi': roi, 'good_frames': good_frames}
-        mask = kwargs['mask'][roi[0]:roi[1], roi[2]:roi[3]]
-        data = np.ascontiguousarray(kwargs['data'][good_frames, roi[0]:roi[1], roi[2]:roi[3]])
-        dct['data'] = (mask * data).sum(axis=1)[:, None].astype(np.float64)
-        dct['whitefield'] = kwargs['whitefield'][roi[0]:roi[1], roi[2]:roi[3]].astype(np.float64)
-        dct['dss_pix'] = kwargs['pixel_translations'][good_frames, 0]
-        dct['dfs_pix'] = kwargs['pixel_translations'][good_frames, 1]
-        return cls(**dct)
-
-    @dict_to_object
-    def crop_data(self, roi):
-        """
-        Return new object with the data cropped according to the given ROI
-        """
-        dct = {'roi': np.array([roi[0] + self.roi[0], roi[1] + self.roi[0],
-                                roi[2] + self.roi[2], roi[3] + self.roi[2]])}
-        dct['data'] = np.ascontiguousarray(self.data[:, roi[0]:roi[1], roi[2]:roi[3]])
-        dct['pix_map'] = np.ascontiguousarray(self.pix_map[:, roi[0]:roi[1], roi[2]:roi[3]])
-        dct['pix_map'][0] -= roi[0]; dct['pix_map'][1] -= roi[2]
-        dct['whitefield'] = self.whitefield[roi[0]:roi[1], roi[2]:roi[3]]
-        dct['ref_img'] = self.ref_img[roi[0]:roi[1], roi[2]:roi[3]]
-        return dct
-
-    @dict_to_object
-    def mask_frames(self, good_frames):
-        """
-        Return new object with the frames masked according to the given good frames array
-        """
-        return {'good_frames': self.good_frames[good_frames],
-                'data': self.data[good_frames],
-                'dss_pix': self.dss_pix[good_frames],
-                'dfs_pix': self.dfs_pix[good_frames]}
+        data = (st_data.get('mask') * st_data.get('data')).sum(axis=1)[:, None].astype(np.float64)
+        whitefield = st_data.get('whitefield').astype(np.float64)
+        pixel_map = st_data.get('pixel_map')[:, [0]]
+        dij_pix = np.ascontiguousarray(np.swapaxes(st_data.get('pixel_translations'), 0, 1))
+        return cls(data=data, dref=st_data, defocus=st_data.defocus, dfs_pix=dij_pix[1],
+                   dss_pix=dij_pix[0], pixel_map=pixel_map, whitefield=whitefield)
 
     @dict_to_object
     def update_reference(self, l_scale=2.5):
@@ -247,12 +269,11 @@ class SpeckleTracking1D:
 
         l_scale - length scale in pixels
         """
-        dct = {}
-        dct['ref_img'], dct['dss_pix'], dct['dfs_pix'] = \
+        reference_image, dss_pix, dfs_pix = \
         make_reference(I_n=self.data, W=self.whitefield,
-                       u=self.pix_map, di=self.dss_pix,
+                       u=self.pixel_map, di=self.dss_pix,
                        dj=self.dfs_pix, ls=l_scale)
-        return dct
+        return {'reference_image': reference_image, 'dfs_pix': dfs_pix, 'dss_pix': dss_pix}
 
     @dict_to_object
     def update_pixel_map(self, wfs, l_scale=2.5):
@@ -262,17 +283,31 @@ class SpeckleTracking1D:
         wfs - search window size in pixels
         l_scale - length scale in pixels
         """
-        pix_map = update_pixel_map_search(I_n=self.data, W=self.whitefield, I0=self.ref_img,
-                                          u0=self.pix_map, di=self.dss_pix, dj=self.dfs_pix,
-                                          dss=self.dss_avg, dfs=self.dfs_avg, wss=1, wfs=wfs // 2)
-        return {'pix_map': gaussian_filter(pix_map, (0, 0, l_scale))}
+        pixel_map = update_pixel_map(I_n=self.data, W=self.whitefield, I0=self.reference_image,
+                                     u0=self.pixel_map, di=self.dss_pix, dj=self.dfs_pix,
+                                     dss=self.dss_avg, dfs=self.dfs_avg, wss=1, wfs=wfs // 2)
+        pixel_map = gaussian_filter(pixel_map, (0, 0, l_scale))
+        return {'pixel_map': pixel_map}
 
-    def mse(self):
+    def update_data(self):
         """
-        Return mean-squared-error (MSE)
+        Update bound STData object
         """
-        return total_mse(I_n=self.data, W=self.whitefield, I0=self.ref_img,
-                         u=self.pix_map, di=self.dss_pix, dj=self.dfs_pix)
+        self.dref._update_pixel_map_1d(self.pixel_map[1])
+        self.dref.reference_image = self.reference_image
+
+    def defocus_sweep(self, df_arr, l_scale=120):
+        """
+        Calculate reference images for an array of defocus distances df_arr
+        Return a new object with optimal defocus distance and a defocus sweep scan
+        """
+        sweep_scan = []
+        for defocus in df_arr:
+            dss_pix, dfs_pix = self.dss_pix * self.defocus / defocus
+            reference_image = make_reference(I_n=self.data, W=self.whitefield, u=self.pixel_map,
+                                             di=dss_pix, dj=dfs_pix, ls=l_scale)[0]
+            sweep_scan.append(np.mean(np.gradient(reference_image[0])**2))
+        return np.array(sweep_scan)
 
     def iter_update(self, wfs, l_scale=2.5, n_iter=5, verbose=True):
         """
@@ -289,10 +324,134 @@ class SpeckleTracking1D:
             errors.append(obj.mse())
             if verbose:
                 print('Iteration No. {:d}: MSE = {:.5f}'.format(it, errors[-1]))
+            u0 = obj.pixel_map
             obj.update_pixel_map.inplace_update(wfs=wfs, l_scale=l_scale)
-            wfs = int(np.max(np.abs(obj.pix_map - np.indices(obj.whitefield.shape))))
+            wfs = max(int(np.abs(obj.pixel_map - u0).max()), self.MIN_WFS)
             if verbose:
                 print('Iteration No. {:d}: Search window size = {:d}'.format(it, wfs))
             obj.update_reference.inplace_update(l_scale=l_scale)
         return obj, errors
-   
\ No newline at end of file
+
+    def mse(self):
+        """
+        Return mean-squared-error (MSE)
+        """
+        return total_mse(I_n=self.data, W=self.whitefield, I0=self.reference_image,
+                         u=self.pixel_map, di=self.dss_pix, dj=self.dfs_pix)
+
+    def var_pixel_map(self, l_scale=20):
+        """
+        Return the pixel map variance
+        """
+        var_psn = np.mean(self.data)
+        reference_image = make_reference(I_n=self.data, W=self.whitefield, u=self.pixel_map,
+                                         di=self.dss_pix, dj=self.dfs_pix, ls=l_scale)[0]
+        dref_avg = np.mean(np.gradient(reference_image[0])**2)
+        N, K = self.data.shape[0], self.data.shape[-1] / (self.dfs_pix[0] - self.dfs_pix[1])
+        return var_psn * (1 / N + 1 / N / K) / dref_avg / np.mean(self.whitefield**2)
+
+class AbberationsFit:
+    """
+    Lens abberations model fitting class
+
+    max_order - maximum polinomial order of the model function
+    """
+    def __init__(self, max_order=2):
+        self.max_order = max_order
+
+    def bounds(self, pixels):
+        """
+        Return the bounds of the regression problem
+        """
+        lb = -np.inf * np.ones(self.max_order + 2)
+        ub = np.inf * np.ones(self.max_order + 2)
+        lb[-1] = 0; ub[-1] = pixels.shape[0]
+        return (lb, ub)
+
+    def errors(self, fit, pixels, pixel_ab):
+        """
+        Return the model errors
+        """
+        return self.model(fit, pixels) - pixel_ab
+
+    def init_x(self, pixels, pixel_ab):
+        """
+        Return initial fit coefficients
+        """
+        x0 = np.zeros(self.max_order + 2)
+        u0 = gaussian_filter(pixel_ab, pixel_ab.shape[0] // 10)
+        if np.median(np.gradient(np.gradient(u0))) > 0:
+            idx = np.argmin(u0)
+        else:
+            idx = np.argmax(u0)
+        x0[-1] = pixels[idx]
+        return x0
+
+    def model(self, fit, pixels):
+        """
+        Return the model values of pixel abberations
+        """
+        return np.polyval(fit[:-1], pixels - fit[-1])
+
+    def angles_model(self, fit, pixels, st_data):
+        """
+        Return the model values of abberation angles
+        """
+        pix_ap = st_data.x_pixel_size / st_data.distance
+        return self.model(self.to_ang_fit(fit, st_data), pixels * pix_ap)
+
+    def phase_model(self, fit, pixels, st_data):
+        """
+        Return the model values of lens' phase
+        """
+        pix_ap = st_data.x_pixel_size / st_data.distance
+        return self.model(self.to_ph_fit(fit, pixels, st_data), pixels * pix_ap)
+
+    def weighted_errors(self, fit, pixels, pixel_ab, weights):
+        """
+        Return the weighted model errors
+        """
+        return weights * self.errors(fit, pixels, pixel_ab)
+
+    def to_ang_fit(self, fit, st_data):
+        """
+        Convert pixel abberations fit to angle abberations fit
+        """
+        pix_ap = st_data.x_pixel_size / st_data.distance
+        ang_fit = fit * pix_ap
+        ang_fit[:-1] /= np.geomspace(pix_ap**self.max_order, 1, self.max_order + 1)
+        return ang_fit
+
+    def to_ph_fit(self, fit, pixels, st_data):
+        """
+        Convert pixel abberations fit to phase fit
+        """
+        pix_ap = st_data.x_pixel_size / st_data.distance
+        ph_fit = np.zeros(self.max_order + 3)
+        ang_fit = self.to_ang_fit(fit, st_data)
+        ph_fit[:-2] = ang_fit[:-1] * 2 * np.pi / st_data.wavelength * st_data.defocus / \
+                      np.linspace(self.max_order + 1, 1, self.max_order + 1)
+        ph_fit[-1] = ang_fit[-1]
+        ph_fit[-2] = np.mean(st_data.get('phase') - self.model(ph_fit, pixels * pix_ap))
+        return ph_fit
+
+    def _fit(self, pixels, pixel_ab, xtol=1e-14, ftol=1e-14, loss='cauchy'):
+        fit = least_squares(self.errors, self.init_x(pixels, pixel_ab),
+                            bounds=self.bounds(pixels), loss=loss,
+                            args=(pixels, pixel_ab), xtol=xtol, ftol=ftol)
+        if np.linalg.det(fit.jac.T.dot(fit.jac)):
+            cov = np.linalg.inv(fit.jac.T.dot(fit.jac))
+            err = np.sqrt(np.sum(fit.fun**2) / (fit.fun.size - fit.x.size) * np.abs(np.diag(cov)))
+        else:
+            err = 0
+        return fit.x, err
+
+    def fit(self, st_data, xtol=1e-14, ftol=1e-14, loss='cauchy'):
+        """
+        Return pixel abberations fit for the STData object
+        """
+        pixels = np.arange(st_data.roi[3] - st_data.roi[2])
+        pixel_ab = st_data.get('deviation_angles')[1, 0] / st_data.x_pixel_size * st_data.distance
+        fit, err = self._fit(pixels, pixel_ab, xtol=xtol, ftol=ftol, loss=loss)
+        r_sq = 1 - np.sum(self.errors(fit, pixels, pixel_ab)**2) / np.sum((pixel_ab.mean() - pixel_ab)**2)
+        return {'fit': fit, 'error': err, 'r_sq': r_sq, 'pixel_ab': pixel_ab, 'pixels': pixels}
diff --git a/st_sim/st_protocol.ini b/st_sim/st_protocol.ini
index bdfd8a7..66fe178 100755
--- a/st_sim/st_protocol.ini
+++ b/st_sim/st_protocol.ini
@@ -1,12 +1,13 @@
 [paths]
-good_frames = /speckle_tracking/good_frames, /frame_selector/good_frames, /process_3/good_frames
-mask = /speckle_tracking/mask, /mask_maker/mask, /entry_1/instrument_1/detector_1/mask,
-translations = /entry_1/sample_1/geometry/translations, /entry_1/sample_1/geometry/translation, /pos_refine/translation, /entry_1/sample_3/geometry/translation
-whitefield = /speckle_tracking/whitefield, /process_1/whitefield, /make_whitefield/whitefield, /process_2/whitefield, /process_3/whitefield
+good_frames = [/speckle_tracking/good_frames, /frame_selector/good_frames, /process_3/good_frames]
+mask = [/speckle_tracking/mask, /mask_maker/mask, /entry_1/instrument_1/detector_1/mask]
+translations = [/entry_1/sample_1/geometry/translations, /entry_1/sample_1/geometry/translation, /pos_refine/translation, /entry_1/sample_3/geometry/translation]
+whitefield = [/speckle_tracking/whitefield, /process_1/whitefield, /make_whitefield/whitefield, /process_2/whitefield, /process_3/whitefield]
 
 [default_paths]
 basis_vectors = /entry_1/instrument_1/detector_1/basis_vectors
 data = /entry_1/data_1/data
+deviation_angles = /speckle_tracking/deviation_angles
 defocus = /speckle_tracking/defocus
 defocus_fs = /speckle_tracking/dfs
 defocus_ss = /speckle_tracking/dss
@@ -29,7 +30,8 @@ y_pixel_size = /entry_1/instrument_1/detector_1/y_pixel_size
 
 [dtypes]
 basis_vectors = f8
-data = f4
+data = f8
+deviation_angles = f8
 defocus = f8
 defocus_fs = f8
 defocus_ss = f8
@@ -46,6 +48,6 @@ reference_image = f8
 roi = i8
 translations = f8
 wavelength = f8
-whitefield = f4
+whitefield = f8
 x_pixel_size = f8
 y_pixel_size = f8
\ No newline at end of file
diff --git a/st_sim/st_wrapper.py b/st_sim/st_wrapper.py
index dcf88c3..679a709 100755
--- a/st_sim/st_wrapper.py
+++ b/st_sim/st_wrapper.py
@@ -10,9 +10,10 @@ import logging
 import datetime
 import argparse
 from sys import stdout
+import re
 import h5py
 import numpy as np
-from .bin import aperture, barcode_steps, barcode, lens
+from .bin import aperture, barcode_steps, barcode_2d, lens
 from .bin import make_frames, make_whitefield
 from .bin import fraunhofer_1d, fraunhofer_2d
 
@@ -57,20 +58,32 @@ class INIParser():
     INI files parser class
     """
     err_txt = "Wrong format key '{0:s}' of option '{1:s}'"
+    known_types = {'int': int, 'float': float, 'bool': bool, 'str': str}
     attr_dict, fmt_dict = {}, {}
+    LIST_SPLITTER = r'\s*,\s*'
+    LIST_MATCHER = r'^\[([\s\S]*)\]$'
 
     def __init__(self, **kwargs):
         for section in self.attr_dict:
+            self.__dict__[section] = {}
             if 'ALL' in self.attr_dict[section]:
-                self.__dict__[section] = kwargs[section]
+                for option in kwargs[section]:
+                    self._init_value(section, option, kwargs)
             else:
-                self.__dict__[section] = {option: kwargs[section][option]
-                                          for option in self.attr_dict[section]}
+                for option in self.attr_dict[section]:
+                    self._init_value(section, option, kwargs)
+
+    def _init_value(self, section, option, kwargs):
+        fmt = self.get_format(section, option)
+        if isinstance(kwargs[section][option], list):
+            self.__dict__[section][option] = [fmt(part) for part in kwargs[section][option]]
+        else:
+            self.__dict__[section][option] = fmt(kwargs[section][option])
 
     @classmethod
     def read_ini(cls, ini_file):
         """
-        Read ini file
+        Read the ini_file
         """
         if not os.path.isfile(ini_file):
             raise ValueError("File {:s} doesn't exist".format(ini_file))
@@ -79,23 +92,28 @@ class INIParser():
         return ini_parser
 
     @classmethod
-    def get_value(cls, ini_parser, section, option):
+    def get_format(cls, section, option):
+        """
+        Return the attribute's format
+        """
         fmt = cls.fmt_dict.get(os.path.join(section, option))
         if not fmt:
             fmt = cls.fmt_dict.get(section)
-        if fmt == 'float':
-            val = ini_parser.getfloat(section, option)
-        elif fmt == 'int':
-            val = ini_parser.getint(section, option)
-        elif fmt == 'bool':
-            val = ini_parser.getboolean(section, option)
-        elif fmt == 'str':
-            val = ini_parser.get(section, option)
-        elif fmt == 'list':
-            val = set(ini_parser.get(section, option).split(', '))
+        return cls.known_types[fmt]
+
+    @classmethod
+    def get_value(cls, ini_parser, section, option):
+        """
+        Return an attribute from the ini_parser
+        """
+        fmt = cls.get_format(section, option)
+        string = ini_parser.get(section, option)
+        is_list = re.search(cls.LIST_MATCHER, string)
+        if is_list:
+            return [fmt(part.strip())
+                    for part in re.split(cls.LIST_SPLITTER, is_list.group(1))]
         else:
-            raise ValueError(cls.err_txt.format(fmt, option))
-        return val
+            return fmt(string.strip())
 
     @classmethod
     def import_ini(cls, ini_file):
@@ -177,18 +195,22 @@ class STParams(INIParser):
     ap_y - lens size along the y axis [um]
     focus - focal distance [um]
     alpha - third order abberations [rad/mrad^3]
+    x0 - lens' abberation center point [0.0 - 1.0]
 
     [barcode - barcode parameters]
     bar_size - average bar size [um]
     bar_sigma - bar haziness width [um]
-    attenuation - bar attenuation
+    bar_atn - bar attenuation
+    bulk_atn - bulk attenuation
     random_dev - bar random deviation
+    offset - sample's offset at the beginning and the end of the scan [um]
     """
     attr_dict = {'exp_geom': ('defoc', 'det_dist', 'step_size', 'n_frames'),
                  'detector': ('fs_size', 'ss_size', 'pix_size'),
                  'source':   ('p0', 'wl', 'th_s'),
-                 'lens':     ('ap_x', 'ap_y', 'focus', 'alpha'),
-                 'barcode':  ('bar_size', 'bar_sigma', 'attenuation', 'random_dev'),
+                 'lens':     ('ap_x', 'ap_y', 'focus', 'alpha', 'x0'),
+                 'barcode':  ('bar_size', 'bar_sigma', 'bar_atn',
+                              'bulk_atn', 'random_dev', 'offset'),
                  'system':   ('verbose',)}
 
     fmt_dict = {'exp_geom': 'float', 'exp_geom/n_frames': 'int',
@@ -196,13 +218,33 @@ class STParams(INIParser):
                 'source': 'float', 'lens': 'float', 'barcode': 'float',
                 'system/verbose': 'bool'}
 
+    @classmethod
+    def lookup_dict(cls):
+        """
+        Return the look-up table
+        """
+        lookup = {}
+        for section in cls.attr_dict:
+            for option in cls.attr_dict[section]:
+                lookup[option] = section
+        return lookup
+
     def __init__(self, **kwargs):
         super(STParams, self).__init__(**kwargs)
-        self._parameters = self.export_dict()
+        self.__dict__['_lookup'] = self.lookup_dict()
 
     def __getattr__(self, attr):
-        if attr in self._parameters:
-            return self._parameters[attr]
+        if attr in self._lookup:
+            return self.__dict__[self._lookup[attr]][attr]
+        else:
+            raise AttributeError(attr + " doesn't exist")
+
+    def __setattr__(self, attr, value):
+        if attr in self._lookup:
+            fmt = self.get_format(self._lookup[attr], attr)
+            self.__dict__[self._lookup[attr]][attr] = fmt(value)
+        else:
+            raise AttributeError(attr + ' not allowed')
 
     @classmethod
     def import_dict(cls, **kwargs):
@@ -224,7 +266,7 @@ class STParams(INIParser):
         th_lim = fx_lim + self.wl / 2 / np.pi * self.alpha * 3e9 * fx_lim**2 / dist
         return np.tan(th_lim) * dist
 
-    def roi(self, dist, x_min, x_max, dx):
+    def roi(self, shape):
         """
         Return ROI for the given coordinate array based on incident beam span
 
@@ -232,8 +274,11 @@ class STParams(INIParser):
         x_min, x_max - coordinate array extremities
         dx - coordinate array step
         """
-        beam_span = np.clip(self.beam_span(dist), x_min, x_max)
-        return ((beam_span - x_min) // dx).astype(np.int)
+        beam_span = np.clip(self.beam_span(self.det_dist),
+                            -shape[-1] // 2 * self.pix_size,
+                            (shape[-1] // 2 - 1) * self.pix_size)
+        fs_roi = (beam_span // self.pix_size + shape[-1] // 2).astype(np.int)
+        return np.array([0, shape[1], fs_roi[0], fs_roi[1]])
 
     def export_dict(self):
         """
@@ -282,12 +327,15 @@ def parameters(**kwargs):
     ap_y - lens size along the y axis [um]
     focus - focal distance [um]
     alpha - third order abberations [rad/mrad^3]
+    x0 - lens' abberation center point [0.0 - 1.0]
 
     [barcode - barcode parameters]
     bar_size - average bar size [um]
     bar_sigma - bar haziness width [um]
-    attenuation - bar attenuation
-    random_dev - bar random deviation 
+    bar_atn - bar attenuation
+    bulk_atn - bulk attenuation
+    random_dev - bar random deviation
+    offset - sample's offset at the beginning and the end of the scan [um]
     """
     st_params = STParams.import_ini(os.path.join(ROOT_PATH, 'parameters.ini')).export_dict()
     st_params.update(**kwargs)
@@ -298,15 +346,18 @@ class STSim():
     Speckle Tracking simulation class (STSim)
 
     st_params - STParams class object
+    bsteps - coordinates of each sample's bar
     """
     log_dir = os.path.join(ROOT_PATH, '../logs')
 
-    def __init__(self, st_params):
+    def __init__(self, st_params, bsteps=None):
         self.parameters = st_params
         self.__dict__.update(**self.parameters.export_dict())
         self._init_logging()
-        self._init_sample_data()
-        self._init_det_data()
+        self._init_coord()
+        self._init_lens()
+        self._init_barcode(bsteps)
+        self._init_detector()
 
     def _init_logging(self):
         self.logger = logging.getLogger(self.__class__.__name__)
@@ -320,7 +371,7 @@ class STSim():
         self.logger.info('Initializing')
         self.logger.info('Current parameters')
 
-    def _init_sample_data(self):
+    def _init_coord(self):
         # Initializing coordinate parameters
         xx_span = self.fs_size * self.pix_size
         yy_span = self.ss_size * self.pix_size
@@ -339,35 +390,39 @@ class STSim():
         self.y_arr = np.linspace(-y_span / 2, y_span / 2, n_y)
         self.xx_arr = np.linspace(-xx_span / 2, xx_span / 2, self.fs_size, endpoint=False)
         self.yy_arr = np.linspace(-yy_span / 2, yy_span / 2, self.ss_size, endpoint=False)
-        x_roi = self.parameters.roi(dist=self.det_dist + self.defoc, dx=self.pix_size,
-                                    x_min=-self.fs_size // 2 * self.pix_size,
-                                    x_max=(self.fs_size // 2 - 1) * self.pix_size)
-        self.roi = np.concatenate((self.ss_size // 2 + np.arange(2), x_roi))
 
+    def _init_lens(self):
         #Initializing wavefields at the sample's plane
         self.logger.info("Generating wavefields at the sample's plane")
         self.wf0_x = lens(x_arr=self.x_arr, wl=self.wl, ap=self.ap_x,
-                          focus=self.focus, defoc=self.defoc, alpha=self.alpha)
+                          focus=self.focus, defoc=self.defoc, alpha=self.alpha,
+                          x0=(self.x0 - 0.5) * self.ap_x)
         self.wf0_y = aperture(x_arr=self.y_arr, z=self.focus + self.defoc,
                               wl=self.wl, ap=self.ap_y)
         self.i0 = self.p0 / self.ap_x / self.ap_y
         self.smp_c = 1 / self.wl / (self.focus + self.defoc)
-        self.logger.info("Wavefields generated")
-
-    def _init_det_data(self):
+        self.logger.info("The wavefields have been generated")
+
+    def _init_barcode(self, bsteps):
+        self.logger.info("Generating barcode's transmission coefficients")
+        if bsteps is None:
+            bsteps = barcode_steps(x0=self.x_arr[0] + self.offset, x1=self.x_arr[-1] + \
+                                   self.n_frames * self.step_size - self.offset,
+                                   br_dx=self.bar_size, rd=self.random_dev)
+        self.bsteps = bsteps
+        self.bs_t = barcode_2d(x_arr=self.x_arr, bx_arr=self.bsteps, sgm=self.bar_sigma,
+                               atn0=self.bulk_atn, atn=self.bar_atn, ss=self.step_size,
+                               nf=self.n_frames)
+        self.logger.info("The coefficients have been generated")
+
+    def _init_detector(self):
         self.logger.info("Generating wavefields at the detector's plane")
         self.wf1_y = fraunhofer_1d(wf0=self.wf0_y, x_arr=self.y_arr, xx_arr=self.yy_arr,
                                    dist=self.det_dist, wl=self.wl)
-        self.bsteps = barcode_steps(beam_span=self.x_arr[-1] - self.x_arr[0],
-                                    bar_size=self.bar_size, rnd_dev=self.random_dev,
-                                    step_size=self.step_size, n_frames=self.n_frames)
-        self.bs_t = barcode(x_arr=self.x_arr, bsteps=self.bsteps, b_sigma=self.bar_sigma,
-                            atn=self.attenuation, step_size=self.step_size,
-                            n_frames=self.n_frames)
         self.wf1_x = fraunhofer_2d(wf0=self.wf0_x * self.bs_t, x_arr=self.x_arr,
                                    xx_arr=self.xx_arr, dist=self.det_dist, wl=self.wl)
         self.det_c = self.smp_c / self.wl / self.det_dist
-        self.logger.info("Wavefields generated")
+        self.logger.info("The wavefields have been generated")
 
     def source_curve(self, dist, dx):
         """
@@ -381,16 +436,16 @@ class STSim():
         s_arr = np.exp(-x_arr**2 / 2 / sigma**2)
         return s_arr / s_arr.sum()
 
-    def lens_phase(self):
-        """
-        Return lens wavefront at the sample plane, defocus, and abberations coefficient
-        """
-        roi = self.parameters.roi(self.defoc, self.x_arr[0], self.x_arr[-1], self.x_arr[1] - self.x_arr[0])
-        phase = np.unwrap(np.angle(self.wf0_x))
-        ph_fit = np.polyfit(self.x_arr[roi[0]:roi[1]], phase[roi[0]:roi[1]], 3)
-        defoc = np.pi / self.wl / ph_fit[1]
-        res = {'phase': phase, 'defocus': defoc, 'alpha': -ph_fit[0] * defoc**3 * 1e-9}
-        return res
+    # def lens_phase(self):
+    #     """
+    #     Return lens wavefront at the sample plane, defocus, and abberations coefficient
+    #     """
+    #     roi = self.parameters.roi(self.defoc, self.x_arr[0], self.x_arr[-1], self.x_arr[1] - self.x_arr[0])
+    #     phase = np.unwrap(np.angle(self.wf0_x))
+    #     ph_fit = np.polyfit(self.x_arr[roi[0]:roi[1]], phase[roi[0]:roi[1]], 3)
+    #     defoc = np.pi / self.wl / ph_fit[1]
+    #     res = {'phase': phase, 'defocus': defoc, 'alpha': -ph_fit[0] * defoc**3 * 1e-9}
+    #     return res
 
     def sample_wavefronts(self):
         """
@@ -559,8 +614,8 @@ class STConverter():
         """
         Save STSim object at the given folder
         """
-        self.save(data=data, st_params=st_sim.parameters, dir_path=dir_path,
-                  logger=st_sim.logger, roi=st_sim.roi)
+        self.save(data=data, st_params=st_sim.parameters,
+                  dir_path=dir_path, logger=st_sim.logger)
 
     def save(self, data, st_params, dir_path, logger=None, roi=None):
         """
@@ -589,10 +644,9 @@ class STConverter():
         data_dict = {'data': data, 'mask': np.ones(data.shape[1:], dtype=np.uint8),
                      'good_frames': np.arange(data.shape[0])}
         data_dict['whitefield'] = make_whitefield(mask=data_dict['mask'], data=data)
-        if roi:
-            data_dict['roi'] = np.asarray(roi)
-        else:
-            data_dict['roi'] = np.array([0, data.shape[1], 0, data.shape[2]])
+        if roi is None:
+            roi = st_params.roi(data.shape)
+        data_dict['roi'] = np.asarray(roi)
         with h5py.File(os.path.join(dir_path, 'data.cxi'), 'w') as cxi_file:
             for attr in self.write_attrs:
                 if attr in data_dict:
@@ -624,10 +678,13 @@ def main():
     parser.add_argument('--ap_y', type=float, help="Lens size along the y axis [um]")
     parser.add_argument('--focus', type=float, help="Focal distance [um]")
     parser.add_argument('--alpha', type=float, help="Third order abberations [rad/mrad^3]")
+    parser.add_argument('--x0', type=float, help="Lens' abberations center point [0.0 - 1.0]")
     parser.add_argument('--bar_size', type=float, help="Average bar size [um]")
     parser.add_argument('--bar_sigma', type=float, help="Bar haziness width [um]")
-    parser.add_argument('--attenuation', type=float, help="Bar attenuation")
+    parser.add_argument('--bar_atn', type=float, help="Bar attenuation")
+    parser.add_argument('--bulk_atn', type=float, help="Bulk attenuation")
     parser.add_argument('--random_dev', type=float, help="Bar random deviation")
+    parser.add_argument('--offset', type=float, help="sample's offset at the beginning and the end of the scan [um]")
     parser.add_argument('-v', '--verbose', action='store_true', help="Turn on verbosity")
     parser.add_argument('-p', '--ptych', action='store_true', help="Generate ptychograph data")
 
@@ -648,3 +705,4 @@ def main():
     else:
         data = st_sim.frames()
     st_converter.save_sim(data, st_sim, params['out_path'])
+    st_sim.close()
diff --git a/test.py b/test.py
index e1c5c42..7b9de51 100755
--- a/test.py
+++ b/test.py
@@ -6,24 +6,29 @@ def inv_geomspace(x0, x1, n):
     return (x1 - x0) / (np.log(x1) - np.log(x0)) * (np.log(y) - np.log(x0)) + x0
 
 def main():
-    out_dir = 'results/{var:s}/{var:s}_{val:d}'
-    params = st_sim.defaults()
-    p_scan = 3e7
-    params['det_dist'] = 2e6
-    params['alpha'] = -0.01
-    params['bar_size'] = 0.1
-    params['attenuation'] = 0.3
-    params['n_frames'] = 200
-    params['verbose'] = True
-    params['p0'] = 2e5
-    variable = 'bar_size'
-    values = np.linspace(10, 500, 20, dtype=np.int)
-    for val in values:
-        params[variable] = val
-        params['p0'] = p_scan / val
-        scan = st_sim.STSim(**params)
-        scan.ptych_cxi().save(out_dir.format(var=variable, val=val))
-        scan.close()
+    out_dir = 'results/{var:s}_p{p_scan:.0e}/{var:s}_{val:d}'
+    p_scan = 3e6
+    sample_span = 9.2
+    prm = st_sim.parameters(bar_size=0.5, bar_sigma=0.25, bar_atn=0.2,
+                            bulk_atn=0.2, th_s=8e-5,
+                            offset=2., defoc=150, alpha=0.06,
+                            ap_x=32, x0=0.7, random_dev=0.8)
+    xmax = 0.8 * prm.ap_x / prm.focus * prm.defoc
+    bsteps = st_sim.bin.barcode_steps(x0=-xmax + prm.offset, br_dx=prm.bar_size, rd=prm.random_dev,
+                                      x1=xmax + sample_span - prm.offset)
+    variable = 'n_frames'
+    nf_arr = np.concatenate(([2, 5], np.linspace(10, 100, 10, dtype=np.int)))
+    st_converter = st_sim.STConverter()
+    for n_frames in nf_arr:
+        prm.n_frames = n_frames
+        prm.p0 = p_scan / n_frames
+        prm.step_size = sample_span / n_frames
+        sim = st_sim.STSim(prm, bsteps=bsteps)
+        data = sim.ptychograph()
+        st_converter.save_sim(data, sim, out_dir.format(var=variable,
+                                                        p_scan=p_scan,
+                                                        val=n_frames))
+        sim.close()
 
 if __name__ == "__main__":
     main()
-- 
GitLab