diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml index c4aa31c..3e69dbb 100644 --- a/.github/workflows/draft-pdf.yml +++ b/.github/workflows/draft-pdf.yml @@ -14,7 +14,7 @@ jobs: # This should be the path to the paper within your repo. paper-path: ./paper/paper.md - name: Upload - uses: actions/upload-artifact@v1 + uses: actions/upload-artifact@v3 with: name: paper # This is the output path where Pandoc will write the compiled diff --git a/User guides/Advanced/Gaussian_bump/Gaussian bump potential 1- background plots and power spectrum.ipynb b/User guides/Advanced/Gaussian_bump/Gaussian bump potential 1- background plots and power spectrum.ipynb new file mode 100644 index 0000000..29de826 --- /dev/null +++ b/User guides/Advanced/Gaussian_bump/Gaussian bump potential 1- background plots and power spectrum.ipynb @@ -0,0 +1,1083 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gaussian bump potential 1 - background plots and power spectrum\n", + "\n", + "This is the first in a series of notebooks which will run importance sampling for the Gaussian bump potential. It is commended the reading is familair with\n", + "- [Importance sampling](https://arxiv.org/abs/2206.11234).\n", + "- How to simulate the linear Sasaki-Mukhanov mode equation in inflation. \n", + "- The [PyFPT user guides](https://github.com/Jacks0nJ/PyFPT/tree/main/User%20guides).\n", + "\n", + "These Notebooks are simply meant to make all of the 2D results reproducible and are minimal in details.\n", + "\n", + "In this notebook the background dynamics will be simulated and the power spectrum found.\n", + "\n", + "Throughout natural units with $c = 8\\pi M_{\\rm PL} = \\hbar =1$ are used." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import mystyle\n", + "plt.style.use(mystyle.paper_style)\n", + "\n", + "from scipy.interpolate import CubicSpline\n", + "from scipy.integrate import odeint\n", + "from scipy.integrate import RK45\n", + "from scipy.optimize import root\n", + "from scipy.integrate import quad\n", + "from mpl_toolkits.axes_grid1.inset_locator import zoomed_inset_axes \n", + "from mpl_toolkits.axes_grid1.inset_locator import mark_inset\n", + "from timeit import default_timer as timer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The potential\n", + "This is the [Gaussian bump potential](https://arxiv.org/abs/1911.00057)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def potential(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return V_0*fraction*(1 + K*expo)\n", + "\n", + "def potential_functional_form(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return fraction*(1 + K*expo)\n", + "\n", + "def potential_dif(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction1 = (phi**2)/(m_squared + phi**2)\n", + " fraction2 = (phi)/(m_squared + phi**2) - (phi**3)/((m_squared + phi**2)**2)\n", + " \n", + " term1 = 2*V_0*fraction2*(1 + K*expo)\n", + " term2 = V_0*fraction1*(-K*expo*(phi-phi_0)/(sigma_tilde**2))\n", + " return term1 + term2\n", + "\n", + "# I tested this against an interpolation of my previous derivative\n", + "def potential_ddif(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " square_brackets = 1 + K*expo\n", + " overall_factor = 2*V_0/(m_squared + phi**2)\n", + " \n", + " term1 = -2*potential_dif(phi)*phi/(m_squared + phi**2)\n", + " term2 = overall_factor*(1 - 3*(phi**2)/(m_squared + phi**2) + 2*(phi**4)/((m_squared + phi**2)**2))*\\\n", + " (1 + K*expo)\n", + " term3 = overall_factor*(phi - (phi**3)/(m_squared + phi**2))*(-K*(phi-phi_0)*expo/(sigma_tilde**2))\n", + " term4 = -overall_factor*0.5*phi*K*(3*phi - 2*phi_0)*expo/(sigma_tilde**2)\n", + " term5 = overall_factor*0.5*K*expo*(phi*(phi-phi_0)/(sigma_tilde**2))**2\n", + " \n", + " return term1 + term2 + term3 + term4 + term5\n", + "\n", + "def V_prime_by_V(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction3 = 1/phi - (phi)/(m_squared + phi**2)\n", + " fraction4 = -(phi-phi_0)/(sigma_tilde**2)\n", + " \n", + " term1 = 2*fraction3\n", + " term2 = fraction4*K*expo/(1 + K*expo)\n", + " return term1 + term2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are shown such that the power spectrum peaks at $5 \\times 10^{-3}$ in the astroid mass gap." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "K = 1.17*(10**-3) # This needs all 3 sig fig\n", + "cmb_power = 2*10**-9\n", + "cmb_phi = 3.0\n", + "phi_0 = 2.18812\n", + "m = 0.5\n", + "m_squared = m**2\n", + "sigma_tilde = 1.59*(10**-2)\n", + "\n", + "V_0 = 12*(np.pi**2)*(cmb_power/potential_functional_form(cmb_phi))*(V_prime_by_V(cmb_phi)**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot this" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "phi_values = np.linspace(0.1, 3.5, 1000)\n", + "V_values = potential(phi_values)\n", + "\n", + "small_phi = 3*sigma_tilde\n", + "fig = plt.figure(figsize = [8., 7.])\n", + "ax = plt.axes()\n", + "ax.plot(phi_values, V_values)\n", + "axins = zoomed_inset_axes(ax, 20, loc=7) # zoom = 2\n", + "axins.plot(phi_values, V_values)\n", + "axins.set_xlim(phi_0 - small_phi, phi_0 + small_phi)\n", + "axins.set_ylim(0.999*potential(phi_0 - small_phi), 1.001*potential(phi_0 + small_phi))\n", + "mark_inset(ax, axins, loc1=2, loc2=4, fc=\"none\", ec=\"0.5\")\n", + "plt.draw()\n", + "ax.set_xlabel(r\"$\\phi$\")\n", + "ax.set_ylabel(r\"$V(\\phi)$\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Background simulation\n", + "Let's simulate background dynamics starting on CMB scales until the end of inflation using a Runge-Kutta 45 method" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def klien_gordon(N, vec):\n", + " phi, pi = vec\n", + " dpi_by_dN = -(3 - 0.5*pi**2)*(pi + V_prime_by_V(phi))\n", + " return [pi, dpi_by_dN]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use slow roll at NLO to set the initial conditions with maximum accuracy.\n", + "\n", + "We need second derivative of the potential, where I will do it numerically" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "phi_values = np.linspace(0.1, 3.5, 1000)\n", + "V_dif_values = potential_dif(phi_values)\n", + "V_dif_interpolation = CubicSpline(phi_values, V_dif_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def hubble_param_LO_1(phi):\n", + " return 0.5*(potential_dif(phi)/potential(phi))**2\n", + "\n", + "def hubble_param_LO_2(phi):\n", + " return 2*( (potential_dif(phi)/potential(phi))**2\\\n", + " - V_dif_interpolation(phi, 1)/potential(phi) )\n", + "\n", + "def hubble_param_NLO_1(phi):\n", + " return hubble_param_LO_1(phi)*(1 - hubble_param_LO_2(phi)/3)\n", + "\n", + "def dpi_by_dN_NLO(phi):\n", + " return -(2*hubble_param_NLO_1(phi))**0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now simulate the background" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "phi_in_start = cmb_phi\n", + "dpi_by_dN_in_start = dpi_by_dN_NLO(phi_in_start)\n", + "initial_state = [phi_in_start , dpi_by_dN_in_start]\n", + "\n", + "# Step through the simulations\n", + "N_values = []\n", + "phi_values = []\n", + "phi_diff_values = []\n", + "solution_background = RK45(klien_gordon, 0, initial_state, 57, rtol=10**-12, atol=10**-15)\n", + "\n", + "\n", + "# Step through the simulations\n", + "while solution_background.status != 'finished':\n", + " solution_background.step()\n", + " N_values.append(solution_background.t)\n", + " phi_values.append(solution_background.y[0])\n", + " phi_diff_values.append(solution_background.y[1])\n", + "\n", + "N_values = np.array(N_values)\n", + "phi_values = np.array(phi_values)\n", + "phi_diff_values = np.array(phi_diff_values)\n", + "\n", + "sol = np.zeros((len(N_values), 2))\n", + "sol[:, 0] = phi_values\n", + "sol[:, 1] = phi_diff_values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have the general sim, now let's find when it should end and re-simulate, ending at that value." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def hubble_param_1_func(dpi_by_dN):\n", + " return (dpi_by_dN**2)/2 \n", + "\n", + "def hubble_func(phi, pi):\n", + " H_squared = 2*potential(phi)/(6-pi**2)\n", + " return H_squared**0.5\n", + "\n", + "def hubble_param_2_func(phi, pi):\n", + " epsilon_H = hubble_param_1_func(pi)\n", + " V_prime_by_V_value = V_prime_by_V(phi)\n", + " return 2*epsilon_H - V_prime_by_V_value*(6-pi**2)/pi - 6" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def nu_sqaured_func(N):\n", + " epsilon2 = epsilon2_interpolation(N, 0)\n", + " epsilon1 = epsilon1_interpolation(N, 0)\n", + " epsilon2_derivative = epsilon2_interpolation(N, 1)\n", + " return 9/4 - epsilon1 + (3/2)*epsilon2 - (1/2)*epsilon1*epsilon2 + (epsilon2**2)/4\\\n", + " + epsilon2_derivative/2" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "hubble_param_values = np.array([hubble_func(sol[i, 0], sol[i, 1]) for i in range(len(sol[:, 0]))])\n", + "epsilon1_values = np.array([hubble_param_1_func(dpi_by_dN) for dpi_by_dN in sol[:, 1]])\n", + "epsilon2_values = np.array([hubble_param_2_func(sol[i, 0], sol[i, 1]) for i in range(len(sol[:, 0]))])\n", + "\n", + "# interpolation\n", + "hubble_param_interpolation = CubicSpline(N_values, hubble_param_values)\n", + "epsilon1_interpolation = CubicSpline(N_values, epsilon1_values)\n", + "epsilon2_interpolation = CubicSpline(N_values, epsilon2_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.2688430896289513" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "epsilon1_values[-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So this simulated ended after inflation ended. Let's use it to find when inflation actually ended, and then re-simulate" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N end\n", + "56.8826959159262\n", + "phi end\n", + "0.35826387061478066\n" + ] + } + ], + "source": [ + "from scipy.interpolate import interp1d\n", + "N_interpolate = interp1d(epsilon1_values, N_values)\n", + "N_end = N_interpolate(1)\n", + "print(\"N end\")\n", + "print(N_end)\n", + "phi_interpolate = interp1d(epsilon1_values, phi_values)\n", + "phi_end = phi_interpolate(1)\n", + "print(\"phi end\")\n", + "print(phi_end)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's resimulate up to this point" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Step through the simulations\n", + "N_values = []\n", + "phi_values = []\n", + "phi_diff_values = []\n", + "solution_background = RK45(klien_gordon, 0, initial_state, N_end, rtol=10**-12, atol=10**-15)\n", + "\n", + "\n", + "# Step through the simulations\n", + "while solution_background.status != 'finished':\n", + " solution_background.step()\n", + " N_values.append(solution_background.t)\n", + " phi_values.append(solution_background.y[0])\n", + " phi_diff_values.append(solution_background.y[1])\n", + "\n", + "N_values = np.array(N_values)\n", + "phi_values = np.array(phi_values)\n", + "phi_diff_values = np.array(phi_diff_values)\n", + "\n", + "sol = np.zeros((len(N_values), 2))\n", + "sol[:, 0] = phi_values\n", + "sol[:, 1] = phi_diff_values" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "phi end\n", + "0.3582680276468886\n" + ] + } + ], + "source": [ + "print(\"phi end\")\n", + "phi_end = phi_values[-1]\n", + "print(phi_end)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's interpolate over these new values" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "hubble_param_values = np.array([hubble_func(sol[i, 0], sol[i, 1]) for i in range(len(sol[:, 0]))])\n", + "epsilon1_values = np.array([hubble_param_1_func(dpi_by_dN) for dpi_by_dN in sol[:, 1]])\n", + "epsilon2_values = np.array([hubble_param_2_func(sol[i, 0], sol[i, 1]) for i in range(len(sol[:, 0]))])\n", + "\n", + "# interpolation\n", + "hubble_param_interpolation = CubicSpline(N_values, hubble_param_values)\n", + "epsilon1_interpolation = CubicSpline(N_values, epsilon1_values)\n", + "epsilon2_interpolation = CubicSpline(N_values, epsilon2_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "nu_squared_values = np.array([nu_sqaured_func(N_values[i]) for i in range(len(N_values))])\n", + "\n", + "nu_squared_interpolation = CubicSpline(N_values, nu_squared_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "N_for_plotting_logic = (N_values>25) & (N_values" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "epsilon_H_values = np.array([hubble_param_1_func(dpi_by_dN) for dpi_by_dN in sol[:, 1]])\n", + "\n", + "plt.plot(N_values[N_for_plotting_logic], np.log10(epsilon_H_values[N_for_plotting_logic]),\n", + " label=r\"$\\log_{10}{(\\epsilon_{1})}$\")\n", + "plt.plot(N_values[N_for_plotting_logic], epsilon2_values[N_for_plotting_logic], label=r\"$\\epsilon_{2}$\")\n", + "plt.plot(N_values[N_for_plotting_logic], nu_squared_values[N_for_plotting_logic], label=r\"$\\nu^2$\")\n", + "plt.xlabel(r\"$N$\")\n", + "plt.ylim(top=8)\n", + "plt.legend(ncol=2)\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While there is clearly a period of ultra-slow roll, what is its precise duration? Let's find out using standard root-finding techniques and interpolation." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def root_finding_epsilon2(N_guess, epsilon2_chosen=-3):\n", + " def epsilon2_value_diff(N_epsilon2_time):\n", + " return epsilon2_interpolation(N_epsilon2_time) - epsilon2_chosen\n", + " sol_epsilon2_time = root(epsilon2_value_diff, N_guess)\n", + " N_epsilon2_time = sol_epsilon2_time.x\n", + " return float(N_epsilon2_time)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ultra-slow roll started at\n", + "29.84178346243688\n", + "and ended at\n", + "32.25059795813168\n" + ] + } + ], + "source": [ + "N_usr_start_guess = N_values[epsilon2_values<-3][0]\n", + "N_usr_end_guess = N_values[epsilon2_values<-3][-1]\n", + "\n", + "N_usr_start = root_finding_epsilon2(N_usr_start_guess)\n", + "N_usr_end = root_finding_epsilon2(N_usr_end_guess)\n", + "\n", + "print(\"Ultra-slow roll started at\")\n", + "print(N_usr_start)\n", + "print(\"and ended at\")\n", + "print(N_usr_end)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now let's save this " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "data_dict = {}\n", + "data_dict[\"N\"] = N_values\n", + "data_dict[\"phi\"] = phi_values\n", + "data_dict[\"phi_N_diff\"] = phi_diff_values\n", + "data_dict[\"H\"] = hubble_param_values\n", + "data_dict[\"epsilon1\"] = epsilon1_values\n", + "data_dict[\"epsilon2\"] = epsilon2_values\n", + "data_dict[\"nu_squared\"] = nu_squared_values\n", + "\n", + "data_pandas = pd.DataFrame(data_dict)\n", + "\n", + "data_pandas.to_csv(\"gaussian_bump_dynamics_dynamics\"+\".csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mode simulation\n", + "\n", + "To find the power spectrum, we need to be able to simulare a linear mode from deep inside the horizon until Hubble-crossing until the end of inflation. Below are the required functions for the comoving curvature perturbation $\\mathcal{R}$" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def R_initial_condition_BD_with_phase(k, a_0, H_0, epsilon1_0, epsilon2_0, comoving_time):\n", + " phase = np.exp(complex(0, -k*comoving_time))\n", + " R0 = complex(np.divide(1, 2*a_0*(epsilon1_0*k)**0.5), 0)*phase\n", + " R_derivative_0 = -complex(1 + 0.5*epsilon2_0, k/(a_0*H_0))*R0\n", + " return R0, R_derivative_0 \n", + "\n", + "def R_mode_equation(N, vec):\n", + " R, d_R_by_dN = vec\n", + " epsilon1 = epsilon1_interpolation(N)\n", + " epsilon2 = epsilon2_interpolation(N)\n", + " aH = aH_interpolation(N)\n", + " d2_R_by_dN2 = -complex(3 - epsilon1 + epsilon2, 0)*d_R_by_dN - R*(k/(aH))**2\n", + " return [d_R_by_dN, d2_R_by_dN2]" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def comoving_time_func(N_interest, N_end):\n", + " def comoving_time_integrand(N):\n", + " aH = aH_interpolation(N)\n", + " return 1/aH\n", + " comoving_time_value, _ = quad(comoving_time_integrand, N_end, N_interest, limit=1000)\n", + " return comoving_time_value" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def find_cg_time(k, sigma, N_exit):\n", + " def exit_time_func(N_rc_exit):\n", + " return k - sigma*aH_interpolation(N_rc_exit)\n", + " N_guess = N_exit + np.log(sigma**-1)\n", + " sol_rc_time = root(exit_time_func, N_guess)\n", + " N_rc_exit = sol_rc_time.x\n", + " return float(N_rc_exit)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def run_mode_sim(N_exit):\n", + "\n", + " N_time_to_horizon = 6.\n", + " N_starting = N_exit - N_time_to_horizon\n", + "\n", + " H_0 = hubble_param_interpolation(N_starting)\n", + " epsilon1_0 = epsilon1_interpolation(N_starting)\n", + " epsilon2_0 = epsilon2_interpolation(N_starting)\n", + " a_0 = a_interpolation(N_starting)\n", + "\n", + " k = aH_interpolation(N_exit)\n", + "\n", + " comoving_time_0 = comoving_time_func(N_starting, N_end)\n", + "\n", + " N_values_R_sim = []\n", + " R_values = []\n", + " R_diff_values = []\n", + "\n", + " R_0, d_R_by_dN_0 = R_initial_condition_BD_with_phase(k, a_0, H_0, epsilon1_0, epsilon2_0, comoving_time_0)\n", + " initial_state_R = [R_0, d_R_by_dN_0]\n", + " solution_R = RK45(R_mode_equation, N_starting, initial_state_R, N_end, rtol=10**-11, atol=10**-14)\n", + "\n", + " # Only need to do 1 simulation\n", + " while solution_R.status != 'finished':\n", + " solution_R.step()\n", + " N_values_R_sim.append(solution_R.t)\n", + " R_values.append(solution_R.y[0])\n", + " R_diff_values.append(solution_R.y[1])\n", + " N_values_R_sim = np.array(N_values_R_sim)\n", + " R_values = np.array(R_values)\n", + " R_diff_values = np.array(R_diff_values)\n", + " return N_values_R_sim, R_values, R_diff_values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's test it for a mode near the CMB scale to make sure it has the correct overall amplitude" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# Overall scale factor\n", + "a_in = 1." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# Need to normalise the scale factor, this is so reasonable numbers are always used in the numerics.\n", + "# If an an overall normalisation is done, then errors can occur from needing to store very large or small\n", + "# numbers.\n", + "\n", + "N_exit = 7\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_exit))\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_exit))\n", + "\n", + "k = aH_interpolation(N_exit)\n", + "\n", + "N_values_R_sim, R_values, R_diff_values = run_mode_sim(N_exit)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "R_rescaled_values = R_values*(k**3/(2*np.pi**2))**0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.5944606528160838e-09" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.abs(R_rescaled_values[-1])**2" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_values_R_sim-N_exit, np.abs(R_rescaled_values))\n", + "plt.yscale(\"log\")\n", + "plt.xlim(left=-6, right=4)\n", + "plt.ylabel(r\"$|\\mathcal{R}| (k^3/2\\pi^2)^{1/2}$\")\n", + "plt.xlabel(r\"$N - N_{\\rm exit}$\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Correct!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Power spectrum" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To obtain the power spectrum, we need to run many such mode simulations. This is done with the code. Only the value at certian $\\sigma$ values and the end of inflation is kept." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "Taken 3.942743946099654 so far\n", + "50\n", + "Taken 190.11771151900757 so far\n", + "100\n", + "Taken 375.9592401260743 so far\n", + "150\n", + "Taken 562.1504127900116 so far\n", + "200\n", + "Taken 746.8883698619902 so far\n", + "250\n", + "Taken 934.4148605500814 so far\n", + "300\n", + "Taken 1122.8168407930061 so far\n", + "350\n", + "Taken 1313.4340012359899 so far\n", + "400\n", + "Taken 1507.4999519620324 so far\n", + "450\n", + "Taken 1704.7447338360362 so far\n", + "500\n", + "Taken 1898.726762150065 so far\n", + "550\n", + "Taken 2093.7291814390337 so far\n" + ] + } + ], + "source": [ + "from scipy.integrate import RK45\n", + "from timeit import default_timer as timer\n", + "# Define the when the modes left and find their scale\n", + "# Define the time when the different modes are coarse-grained\n", + "\n", + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "N_time_to_horizon = 6.\n", + "\n", + "# Remember to give time for super horizon evolution\n", + "N_modes = np.linspace(N_usr_start-9, N_usr_start+11, 600)\n", + "\n", + "k_raw_values = np.zeros(len(N_modes))\n", + "\n", + "R_at_sigma_values = np.zeros((len(sigma_values), len(N_modes)), dtype=\"complex\")\n", + "R_diff_at_sigma_values = np.zeros((len(sigma_values), len(N_modes)), dtype=\"complex\")\n", + "R_end_values = np.zeros(len(N_modes), dtype=\"complex\")\n", + "\n", + "start_time = timer()\n", + "\n", + "for i in range(len(N_modes)):\n", + " N_exit = N_modes[i]\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_exit))\n", + "\n", + " k = aH_interpolation(N_exit)\n", + "\n", + " N_values_R_sim, R_values, R_diff_values = run_mode_sim(N_exit)\n", + "\n", + " R_interp = interp1d(N_values_R_sim, R_values)\n", + " R_diff_interp = interp1d(N_values_R_sim, R_diff_values)\n", + "\n", + " for j in range(len(sigma_values)):\n", + " sigma = sigma_values[j]\n", + " N_cg = find_cg_time(k, sigma, N_exit)\n", + " R_cg = R_interp(N_cg)\n", + " R_diff_cg = R_diff_interp(N_cg)\n", + "\n", + " R_at_sigma_values[j, i] = R_cg\n", + " R_diff_at_sigma_values[j, i] = R_diff_cg\n", + "\n", + " # Storing\n", + " k_raw_values[i] = k\n", + " R_end_values[i] = R_values[-1]\n", + "\n", + " if (i%50)==0:\n", + " end_time = timer()\n", + " print(i)\n", + " print(\"Taken \"+str(end_time-start_time)+\" so far\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's ca use these to find the power spectrum.\n", + "\n", + "**It is important to store each $k$ value seperately, as each one has a different scale factor normalisation**" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "def power_spectrum_func(k, R):\n", + " return (np.abs(R)**2)*(k**3)/(2*np.pi**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's save these values" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "data_dict = {}\n", + "data_dict[\"N exit\"] = N_modes\n", + "data_dict[\"k\"] = k_raw_values\n", + "data_dict[\"R end\"] = R_end_values\n", + "for j in range(len(sigma_values)):\n", + " data_dict[\"R at sigma \"+str(sigma_values[j])] = R_at_sigma_values[j,:]\n", + " data_dict[\"R diff at sigma \"+str(sigma_values[j])] = R_diff_at_sigma_values[j,:]\n", + "\n", + "data_pandas = pd.DataFrame(data_dict)\n", + "\n", + "data_pandas.to_csv(\"gaussian_bump_range_of_R_values_at_different_sigma\"+\".csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's load this data back in" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "matching_data = pd.read_csv(\"gaussian_bump_range_of_R_values_at_different_sigma\"+\".csv\", index_col=0)\n", + "\n", + "N_modes = np.array(matching_data[\"N exit\"])\n", + "k_raw_values = np.array(matching_data[\"k\"])\n", + "R_end_values = np.array(matching_data[\"R end\"], dtype=np.complex64)\n", + "\n", + "\n", + "R_at_sigma_values = np.zeros((len(sigma_values), len(N_modes)), dtype=\"complex\")\n", + "R_diff_at_sigma_values = np.zeros((len(sigma_values), len(N_modes)), dtype=\"complex\")\n", + "\n", + "for j in range(len(sigma_values)):\n", + " R_at_sigma_values[j, :] = matching_data[\"R at sigma \"+str(sigma_values[j])]\n", + " R_diff_at_sigma_values[j, :] = matching_data[\"R diff at sigma \"+str(sigma_values[j])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's also test it is giving me the correct final form" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "power_spectrum = power_spectrum_func(k_raw_values, R_end_values)\n", + "power_spectrum_at_sigma_001_new = power_spectrum_func(k_raw_values, R_at_sigma_values[-1, :])\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_usr_start))\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_usr_start))\n", + "\n", + "k_usr_start = aH_interpolation(N_usr_start)\n", + "k_usr_end = aH_interpolation(N_usr_end)\n", + "\n", + "k_values_normalised = aH_interpolation(N_modes)/k_usr_start" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvYAAAHoCAYAAAAi1atWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABic0lEQVR4nO3deXxU5d3///cs2SaBkEDIQiBhEYGEJeyIIgiyCWhBBUHFVrm72Vp7u1VbodXe7a/F29Zve1tbWwGlWhEXlFUjiLJHAiGKLJIEkpCQDchC1jm/P0JiIhCyTDLb6/l45NHJnHOd85lynHnPleu6jskwDEMAAAAA3JrZ2QUAAAAAaDuCPQAAAOABCPYAAACAByDYAwAAAB6AYA8AAAB4AII9AAAA4AGszi4A7cdutys/P1+SZLPZZDKZnFwRAAAAGjIMQ2VlZZKkbt26yWxufb87wd6D5efnKzw83NllAAAAoBlyc3PVvXv3VrdnKA4AAADgAeix92A2m63+cW5urgIDA51YDQAAAL6ttLS0foRFw+zWGgR7D9ZwTH1gYCDBHgAAwIW1dT4kQ3EAAAAAD0CwBwAAADwAwR4AAADwAAR7AAAAwAMQ7AEAAAAPQLAHAAAAPADBHgAAAPAABHsAAADAAxDsAQAAAA9AsAcAAAA8AMEeAAAA8AAEewAAAMADEOwBAAAAD0CwBwAAADyA1dkFAADQXi5UViur6ILOllbqbFmVyqtqZDGbZDJJNl+rQgN9FRLoq/Bgf1kt9HUBcG8EewCAx8guuqCdR/OUlFag47klyioqk2FcvZ3FbFJ0qE0x3QI1IKqz4qO7KK5HsAL9+ZgE4D54xwIAuLWzpZVafyBLGw5k6+szJfXP+1rN6h/RWTHdAhUa6Ktgm48CfC0yDMluGCqtqFZRaaUKSiqVWVimUwWlysgv1favzkiSTCapT/cgjenbTWP6ddWwXiHy87E462UCwFUR7AEAbunMuXK9uiNN732eqcpqu8wmaVhMiK67ppvGXROm3mGBLRpeU2M3lFlYpi+zzin11FmlZp7TsZzz+jq3RP/emS4/H7OGx4Zq/DVhmjCwu7p39m/HVwcALWcyjOb8kRLuqLS0VEFBQZKkkpISBQYGOrkiAGi78qoavfpZml77LE0V1XaFBPpq3qiemjM8Wt2DHRu2z1+oUtKJAu0+nq/dxwt05nx5/bbBPbto4sDumjQoXFEhNoeeF4D3cGReI9h7MII9AE9z8GSRfvP2IWUVXVAnf6vum9BX80b1lL9v+w+RMQxDaXml+uRwrrYeztXR08X12/pHdtKUuAhNHRypiC4B7V4LAM9BsEezEOwBeAq73dDL245rxfYTshvS7IQe+tHN/RUS6Ou0mrIKy7Tt8BltO5yrQ6fO1j+fEBOiaUMiNWlQuIJtzqsPgHsg2KNZCPYAPEFpRbWWrk3RZ0fyFBrkq6dujdf4/mHOLquR3HMX9OGhHG0+dFrHcmp78q0Wk667JkxTB0fq+mvD5M/EWwCXQbBHsxDsAbi77KIyPfLvZJ04U6JBPYL1/y0YpjAXn7R64kyJNqec1pZDp3X67AVJks3PokkDw3VLQg8N6xUis9nk5CoBuAqCPZqFYA/AnaXnlejBlUnKL67Q9CGRemJOnFv1ehuGoZRTZ7U55bQSv8jRubIqSVJklwDNHBalmUOj1COUSbeAtyPYo1kI9gDc1de5xfrJqiQVllTqvgl99P2b+slkct9e7uoau3Yey9f6A1nacTRP1TW1H70JsSG6ZVgPTRoUrkA/VqAGvBHBHs1CsAfgjo7nFuvBFft0tqxK/zWpn743sa+zS3Kos6WV2nLotNYfyNaR0+clSf4+Ft00KFy3JEQpISaUoTqAFyHYo1kI9gDcTc7ZC1ry8h7lFVfoR1Ou0b039HF2Se3qWE6xNhzI0qaU0yoqrZQkRXTx18yhUZo5rIeiGaoDeDyCPZqFYA/AnZwrq9T3/7VX6Xmlum9CH/1g8jXOLqnDVNfYtft4vtYfyNanR87UD9UZFhOiW4ZF6aa4CIbqAB6KYO8FTp48qSeffFJJSUnKzs6W3W5XbGys7rzzTj388MPq1KnTVY9BsAfgLiqqavTTVUk6ePKsZg6L0q9ui3frMfVtca6sUh8eytH6A1k6nF07VCfA16LJcRGaldBDQ3t18dr/bwBPRLD3Avv27dOjjz6qcePGqWfPnrJYLEpKStLKlSs1ZMgQ7dq1Sz4+Pk0eg2APwB0YhqFn3k3VhgPZGtuvq5YvHC6rxezsslzC17nFWn8gWxsPZtcP1enV1aZZCT00c1gPdevk5+QKAbQVwd6L/fGPf9Rjjz2m9evXa+bMmU3uS7AH4A7e2nNSyzccVky3QP1ryVgF+jPk5Nuqqu3acSxP7+/P0q5jebIbksVs0rhruml2Qg+N7x/GlyHATTkyr/Hu6WZiY2MlSUVFRc4tBAAc4EBGkZ7f9JVsfhb94a4EQv0V+FjNmjgwXBMHhivvfLk2HszW+8lZ+uxInj47kqeQQF/NHBqlWcN7qHdYkLPLBeAk9Ni7uPLycpWUlOjChQs6cOCAHn74YWVlZeno0aPq2bNnk23psQfgygpKKnTviztVUFKpP9yVoAkDuju7JLdiGIYOnjyr9/dnKvGLXJVX1UiS4qODNXt4tKbERfBFCXADjsxrXvF3u7KyMm3cuFHPPvus5s6dq5iYGJlMJplMJi1btqxZxyguLtayZcs0ePBgBQUFKTg4WKNGjdJzzz2nysrKdqv95ZdfVlhYmHr16qU5c+bI19dX77333lVDPQC4Mrvd0DPvHFLBxRtQEepbzmQyaVhMiH71ncFa/8hE/WJOnAb37KLUzHP63bovdMvybfrNO4d0IKNI9OEB3sErvsrv3bv3quPRm5KRkaGJEycqPT1dkmSz2VRRUaGkpCQlJSVp9erVSkxMVEhIyCVtKysrlZKS0qzzBAQEKC4urtFzt912mwYMGKBz585p586d+vjjj3X+/PlWvxYAcAX/2Z2h3ccLNLhnFz3gYTegcoZAf6tuHRGtW0dEKy2vRB/sz9KGg9nacKD2JzrUptkJPTRzWJTCOvs7u1wA7cQrhuJs27ZNc+fO1fDhw+t/Hn74YeXk5Gjp0qVN9trX1NQoISFBhw4dUmRkpFatWqUpU6bIbrdrzZo1WrJkiYqLizVjxgxt2LDhkvbp6enq3bt3s+qMi4tTampqk/usWbNGd955pz788ENNmTKlyX0ZigPAFR05fV73/2O3/KwWvfrD6xQVEuDskjxSdY1dO47m6f3kLO06lq8auyGzSRp3TZhmJfTQ9f3D5GP1ij/cAy6NybMtdMMNN6iwsLDRc0888USz2q5YsUKHDh2SJK1du1bjxo2TJJnNZs2fP192u10LFy7Uxo0blZiYqMmTJzdqHxERoa1btzbrXM35h5w7d678/f31yiuvXDXYA4CrKa+q0dNvpai6xtDS7wwi1Lcjq8WsGweG68aB4covrtCGA1n6IDlLO47macfR2gm304dEavbwaPXpzoRbwBN4RbC3WCytbrty5UpJ0qRJk+pDfUMLFizQU089pbS0NK1ateqSYO/v76+JEye2+vzfVl1drerqalbFAeCWXt56XBn5pZo+JFI3D450djleo1snP917Qx/dc31vpZw6q/f3Zynxixy9vitDr+/KUFx0sGYn9NCU+AgF+Td9jxQArou/wTWhrKxMO3bskCTNmDHjsvuYTCZNnz5dkrRlyxaHnTs3N/eyz7/00kuqrq7WmDFjHHYuAOgIX2Se1b93pqtrkK8enjHA2eV4JZPJpKG9QvTL2+L1wSMT9dSttRNuv8g8p9+//yUTbgE35xU99q11+PBh2e12SVJ8fPwV96vblpOTo8LCQoWGhrb53I8//ri+/PJL3XzzzYqJiVFJSYm2b9+udevW6dprr9VDDz3UouOVlpZecRtj7wG0t8pqu3773heyG9JjswYp2Obr7JK8XqCfVbOHR2v28Gil55Xog+TGE25jugVqzvBozRwWpZBA/r0Ad0Cwb0J2dnb94x49elxxv4bbsrOzHRLs586dq4KCAq1cuVJ5eXmyWq3q16+ffvnLX+qRRx5R586dW3S88PDwK26jVwZAe3vlk6914kyJbo6P0I0Dr/x+BOeIDQvSg1Ov1Q8mX6PPjuZp3eeZ2n08X/9vyxG9mHhUE67trjkjojW6T1eZzSZnlwvgCgj2TSguLq5/bLPZrrhfw20N27TFnDlzNGfOHIccCwCc6cjp81r1WZpCAn3185kDnV0OmmC1fHOH29xzF7Q+OVvrkjP18Ze5+vjLXEV08dfshB6aldBD4cFMfAZcDcHeS+Tm5jLkBkCHq7Eb+p/3vlCN3dB/zxzIkA43Eh4coO9N7Kv7JvTRvhMFWrc/U598dUb/2Pq1Xt72tcb266Y5w6N1w7VhslqYsge4AoJ9Ezp16lT/uKys7Ir7NdzWsI0rCQwMJNgD6HDv7DulI6fPa3z/ME2OYwiOOzKbTRrTr5vG9OumotJKbTyYrfc+z9SuY/nadSxfIYG+umVYlOYMj1avbnzOAM5EsG9CVFRU/eOsrCwNGTLksvtlZWVdtg0AeLOCkgr97eNj8rOa9d8zB8hkYmy2uwsJ9NXC62J117gYpZw6q3WfZ+qjL3L02o50vbYjXQkxIZozIlqTBoXL36f1S00DaB2CfRMGDhwos9ksu92u1NTUKy55WXe32IiICIdMnAUAT/DXLUdVUl6t/7qpn6JCrjxPCe6nbtnMob1C9PCMAfrwUI7e25+p5IwiJWcU6bkNhzV9SKTmDI9W/8iWLfYAoPUYFNcEm82m8ePHS5I2bdp02X0Mw9DmzZslSVOnTu2w2gDAlR3IKNKGg9nq2dWmu8f3dnY5aEdB/j76zqieWvH9cVr5g3G6fXRPSdJbe0/p3r/t0n0v7dLb+06ptLzayZUCno9gfxWLFy+WJG3dulV79uy5ZPuaNWt04sQJSdK9997bobUBgCuqrrHrjx98KUl6ZOZA+Vr5qPEW10Z21iO3DNIHj0zU0rmDlRAToq+yz+sPH9Te/OqZdw7p4ElufgW0F68ZilNUVKSampr63+tuPFVWVqb8/Pz65/39/RUUFFT/++LFi/XnP/9Zhw4d0rx587Ry5UpNnjxZdrtda9eu1ZIlSyTV3pl28uTJHfRqAMB1vbX3pL4+U6LJceEa06+bs8uBE/j7WDRjaJRmDI3SyfxSrdufqfUHsut/uPkV0D5Mhpd8bY6NjVVGRsZV91u8eLFWrFjR6Ln09HRNmjRJ6enpkmqH6NjtdpWXl0uSEhISlJiYqJCQEEeX3SalpaX1X1JKSkpYFQdAuztbWqnbX/hUVTV2rfnJDeoe7O/skuAiqqrttTe/2l978yvDkKwWk24c0F1zhkdrFDe/gpdyZF7zmh77toiNjVVKSoqWL1+ut99+W2lpafLx8VFcXJzuuusu/eQnP5GvLz0OAPDytuMqKa/WAxP7EurRiI/VrEmDwjVpULhyzl7Q+gNZen9/lhK/yFXiF7mK7BKgW0dEa3ZCD3Xt5OfscgG35DU99t6IHnsAHenEmRLd8+JOhQb56s2fXK8AX/qO0LQau6F9Jwr03ueZ2v7VGdXYDVnMJt1wbZi+M7InvfjwCvTYAwBcimEY+vOmr1RjN/SjKf0J9WgWi9mksf26aWy/bioortAHyVl6b3+mth0+o22HzygqJEC3Do/WLHrxgWahx96D0WMPoKPsPJqnn6/er0E9OuvlB8bSy4pWs1/sxX/3W734EwZ0120jGIsPz0OPPQDAZVTX2PXnzUckST+bPoDQhTYxm00a06+bxvTrpvziCq2/2Iu/9ctcbf0yl158oAn02HsweuwBdIS1e0/qj+sPa0p8hJ69Y6izy4EHquvFfyfplD49kte4F39ktEb1phcf7oseewCASyirqNY/P/laVotJP5x8jbPLgYf6di/+B8lZeu/zb3rxe4TUrqhzS0IPdQ2iFx/eix57D0aPPYD29q9tX+vvW4/rzjG99POZA51dDryI3W5o78Ve/M8a9OLfOKC7bhvZUyN7h9KLD7fgyLxGsPdgBHsA7amotFLz/rRdMklrH5rAHUThNPnFFXp/f6be25+pnLO1N4+MDg3QnOH04sP1EezRLAR7AO3pfzcc1pt7Tuq/JvXT9yb2dXY5gGrshvZ+na93P8+s78Wvu7vtrSPoxYdrYow9AMCpsgrL9HbSKYUG+WrBuBhnlwNIql0Xf9w1YRp3TZjyzpfXr4tfd3fb6NAAfWdkT81K6KFgG39hguehx96D0WMPoL0sXZuizSmn9egtAzVvdC9nlwNcUX0vflKmPj1yRnZD8rWaNTkuQvNG9VRcdLBMJnrx4Tz02AMAnObI6fPanHJa0aE23Toi2tnlAE1q2It/5ly53vu8diz+xoPZ2ngwW/0jOmnuqJ6aOjhSNj9iEdwbPfYejB57AO3hZ68maffxAj17x1BNiY9wdjlAi1XX2LX9yBm9vfeUktIKJUmBflbNGBqleaN6qnf3ICdXCG/C5Fk0C8EegKMlpxfqh6/s04CozvrXkrFMRITby8gv1Tv7Tmn9gSwVl1dLkhJiQjR3VE9NHBguH6vZyRXC0xHs0SwEewCOZBiGfvTKPiVnFOn5u4dr3DVhzi4JcJjyyhp9mHpab+87pcPZ5yVJIYG+mjM8WreNjFZklwAnVwhPRbBHsxDsATjS3q8L9NNVSRrcs4v+fv9oJhzCYx3OOqe3953SltTTqqiyy2ySxl0Tpnmje2ps3278pQoORbBHsxDsATiKYRha8vIepWae01/vG6kRvbs6uySg3Z2/UKUNB7L09r5TOllQJkmKCgnQbSOiNXt4NDdlg0MQ7NEsBHsAjrLzaJ5+vnq/RvQO1V/vG+XscoAOZRiGPk8r1Np9p7T9qzOqsRvysZg0aVCE5o3uqSE9u/AXLLQay10CADqMYRh66ePjkqT/uqmfk6sBOp7JZNLIPl01sk9X5Z0v17r9mXr380xtOXRaWw6d1jURnXT76F6aNjhS/r4WZ5cLL0aPvQejxx6AI2w7nKsn3jigsf266k/3jHR2OYBLqK6xa8fRPL2195T2nSiQJHUOsGp2QrTmjuqpHqE2J1cId8FQHDQLwR5AW9nthu55cae+PlOif/3XWA3qEezskgCXk55XorUXl8wsq6iRySRdd02Y7hzTS6P6dGWyLZpEsEezEOwBtNWHqaf1qzUpuuHaMP1x4XBnlwO4tNLyam08mK01e08qI79UktSrq03zRvfSLcOiFOTv4+QK4YoI9mgWgj2AtqixG1r41x3KyC/Vqz8cp2siOju7JMAtGIahfScK9dbek/rsyBnZDcnma9GMoVG6fXQv7myLRpg8CwBod1sOnVZGfqluGhROqAdawGQyaXTfrhrdt6uyiy7o7X0ntW5/ltbuO6W1+05pZO9Q3TGml8b3D5PVwp1t4Tj02HsweuwBtFZ1jV13/XWHMgvLtPpH49WHHkagTcqravRRao7e3JOho6eLJUkRwf6aO6qn5gyPVhfWxPdaDMVBsxDsAbTWppRsLVt7SFPiI/TsHUOdXQ7gMQzD0KFTZ/XW3pNK/CJXNXZDvlazbo6P0B1jemlAFBPUvQ3BHs1CsAfQGg3H1q/+0XXqG97J2SUBHim/uELvJp3SO0mnVFBSKUmKjw7W/LExmjQonGE6XoIx9gCAdvPxlznKyC/VpEHhhHqgHXXr5KcHJvXT4hv6aNvhXK3Ze1IpJ88q9a0UhXX20x2je+nWEdEKtjFMB81Dj70Ho8ceQEvZ7YbufnGnTpwp0aofjFP/SCbNAh3pq+zzenN3hraknlZ1jSE/H7NmDInS/LExrKbjoRiKg2Yh2ANoqY+/yNGTbx7UhAHd9Ye7EpxdDuC1Coor9Pa+U3o76ZSKSmuH6Yzp21Xzx8VobN9u3PTKgxDs0SwEewAtYbcbuvdvO3U8t0Qrvj9OA6LorQecraKqRh+m5uiNXek6nlsiSYrpFqg7x/TSzGFRCvBlVLW7I9ijWQj2AFrik8O5evyNAxrfP0zPLeIus4ArMQxD+9OL9J/dGfr0yBkZhtTJ36o5I6J1x+heiugS4OwS0UpMngUAOJRhGPrnJ19Lkr53Yx8nVwPg20wmk0b0DtWI3qHKLCzTW3tOal1yplbvSNcbuzI0cWB3zR8bo8E9u8hkYpiOt6LH3oPRYw+guT47ckaP/DtZY/t105/uGeHscgA0Q2l5tT5IztKbezKUVXRBkjSoR2fdOTZGU+IiWC7TTTAUB81CsAfQHIZh6P5/7NaXWef1jwfGaHDPLs4uCUAL1NgN7Tiap//sztDnaYWSpO6d/TV/bO1ymUH+Pk6uEE0h2KNZCPYAmmPnsTz9/LX9GtWnq/7f4pHOLgdAGxzLOa/Xd2Voy6Ha5TJtfhbdOjxa88fGMA7fRRHs0SwEewBXYxiGHnh5j77IPKe/fW+0hsWEOLskAA6Qd75ca/ac1DtJp1RcXi2L2aTJceFaeF1vVrxyMQR7NAvBHsDV7P26QD9dlaThsSH6v++OdnY5ABysrKJa7ydn6Y1dGTp9tnYc/ojeoVp4XazG9WM9fFfAqjgAAIdY+ekJSdL3buzr5EoAtAebn1Xzx8Zo3qie2nb4jP69M02fpxXq87RCxYYFauG4WE0bEik/H4uzS4UD0GPvweixB9CUQ6fOasnLexQXHayXHxjDEnmAFzAMQwcyivTvnen69EieJCkk0Fd3jOmleaN6Ktjm6+QKvQ899gCANqvrrV98Qx9CPeAlTCaTEmJDlRAbqoz8Ur2xK13rD2Tr7x8f18pPT2jWsB5aeF2seoTanF0qWoEeew9Gjz2AKzmWU6x7Xtypvt2D9OoPr2OcLeDFCksqtHbfKa3de1Jny6pkNklT4iN0z/W9dU0EE23bGz32AIA2WXWxt/7eG3oT6gEvFxrkpyWT+ume63vrg+Qs/XtnurYcytGWQzkad0033Xt9bw2LCeEve26AYA8AXuZkQakSv8hRj5AATY6LcHY5AFyEv49Ft4/updtGROvjL3O16tMT2nUsX7uO5Ss+Olj33tBH1/cPozPAhRHsAcDLvPZZmuyGdM/1vbnlPIBLWC1mTR0cqZvjI7TreL5e/TRNyRlFeuz1ZMWGBeqe63tranykfKy8f7gaxth7MMbYA/i2M+fKNffP2xVi89Xan02QLx/MAJoh5WSRXv0srX4lnfBgfy0cF6s5I3oowJd+4rbgBlVoFoI9gG/708av9MbuDD007VrddV2ss8sB4GbSzpTo1R1p2pxyWjV2Q50DfHTnmF66Y0wvlspsJYI9moVgD6ChotJKfef57fLzMeudn02QzY9eNgCtk3P2gl7fla73Ps9SeVWN/H0sum1ktO4e31vdOvk5uzy34si8xt9gAcBL/Gd3hsqrajR/TAyhHkCbRHQJ0MMzBurdhyfo/ol95Ws16Y1dGZr7p+1avv5L5Z674OwSvRLB3kWlp6fLZDJd9ue+++5zdnkA3ExJeZXe2ntSNl+Lbh/Ty9nlAPAQXQJ9tWRSP73z8I368c39Fehn1Vt7T2nenz/V/7yXqqzCMmeX6FXosnFxs2bN0vz58xs917dvXydVA8Bdvb3vlErKq3X3+Fh1DvBxdjkAPEygn1X3XN9bd4zupXc/P6XXdqRr3f4srT+QrWmDI7V4Qh/FdGNIcHsj2Lu4uLg43X333c4uA4AbK6+s0eu7MuRrNeuucbHOLgeAB/P3tWjBuFh9Z2RPfZCcpVc/S9OGg9namJKtyXERum9CH/UL7+TsMj0Wwd4NlJeXyzAMBQQEOLsUAG7o/eRMFZVWat6onurKpDYAHcDPx6J5o3tpzvBobUrJ1spPT+ij1Bx9lJqjGwd013dv7KsBUZ2dXabHYYy9i/vrX/8qm80mm82mvn376vnnnxcLGQForqpqu17bkS6L2aRF43s7uxwAXsbHatbs4dF648HrtWzeYMWGBeqTr87ovpd26eevfa7UzLPOLtGjeEWwLysr08aNG/Xss89q7ty5iomJqZ+IumzZsmYdo7i4WMuWLdPgwYMVFBSk4OBgjRo1Ss8995wqKysdXrPZbNbkyZP1u9/9Tu+9955eeuklhYaG6uc//7l+/OMfO/x8ADzT5kOnlXuuXNOGRCoqhL/6AXAOq8Ws6UOi9O8fjddv7xyqfuFB2nksXw/8Y4/+e/V+fZV9ztklegSvWMd+27ZtmjRp0mW3LV269KrhPiMjQxMnTlR6erokyWazqaamRhUVFZKkhIQEJSYmKiQk5JK2lZWVSklJaVadAQEBiouLu+L2mpoa3XTTTdq+fbtSU1Ob3FdiHXvA29XYDd31l890qrBM//7xePUOC3J2SQAgSTIMQ58eydM/th7XsZxiSdKEAd31wMS+6h/pXUN0HJnXvGaMfUhIiIYPH17/8/DDDysnJ+eq7WpqajR79mylp6crMjJSq1at0pQpU2S327VmzRotWbJEycnJWrRokTZs2HBJ++zsbI0aNapZNcbFxSk1NfWK2y0Wix5//HFt375dH3300VWDPQDvtu1wrk4WlGnSoHBCPQCXYjKZNGFAd13fP0zbvsrVy1u/1vavzmj7V2c0aVC4HpjYV32ZZNtiXhHsb7jhBhUWFjZ67oknnmhW2xUrVujQoUOSpLVr12rcuHGSaofKzJ8/X3a7XQsXLtTGjRuVmJioyZMnN2ofERGhrVu3NutczfmGFhsbK0kqKCho1jEBeCfDMLTy0xOSpMU3MLYegGsym026aVCEJg4IV+KXOXp569fa+mWuth3O1eS4CN0/sS8dEy3gFcHeYrG0uu3KlSslSZMmTaoP9Q0tWLBATz31lNLS0rRq1apLgr2/v78mTpzY6vN/2/HjxyVJ4eHhDjsmAM+z90SBjp4u1qg+XTUgKtjZ5QBAk8xmk26Oj9RNgyL0Yepp/XPb1/ooNUeJX+Ro6uBI3X9jX/ViHfyr8orJs61VVlamHTt2SJJmzJhx2X1MJpOmT58uSdqyZYvDzv3tvzBItctePvPMM7JYLPXnbK7S0tIr/gDwPK9+liZJuud6eusBuA+L2aTpQ6L0+o/H61ffiVdUlwBtTjmtBX/5TL9555AyuZNtk7yix761Dh8+LLvdLkmKj4+/4n5123JyclRYWKjQ0NA2n/uBBx5QaWmpxo0bp+joaJ0+fVqrVq3S8ePHtXTp0hbffbapHn4vmD8NeJWvss8p6UShBkR11qg+bX8/AoCOZrWYdcuwHpo2OFLrD2TrlU++1oYD2dqcclq3jYjWd2/sq27cl+MSBPsmZGdn1z/u0aPHFfdruC07O9shwf6WW27RypUr9eKLL6qwsFCBgYEaPny4fv/732vevHltPj4Az9Wwt95kMjm5GgBoPavFrFtHRGvm0Cit25+pV7af0Np9p7T+QLbmj43R3eNj1SnAx9llugyCfROKi4vrH9tstivu13BbwzZtcf/99+v+++93yLEkKTc3l+UuAS9wqqBUW7/MVXSoTRMHMhcHgGfwsZo1b3Qv3TKsh97ck6FXP0vTyk9P6J2kk7r3+j66fUwv+fu0fk6lp2CMvZcIDAy84g8Az/HvnemyG9Ki62JlMdNbD8Cz+PtadO8NfbT2ZxO0+Ibeqqi26y8fHtUdf/5U7yadUnWN3dklOhXBvgmdOn2zfmpZ2ZUnazTc1rANAHSkguIKrT+QrdAgX80cFuXscgCg3XQO8NEPp/TX2ocmaO6oniosrdTv3/9Sd/11hz5KzZHd7p3zBwn2TYiK+uaDMSsr64r7NdzWsA0AdKQ392Sostqu+WNi5MefpAF4gW6d/PTYrEF648Hxmjo4QqcKyvTLNQf13b/v1p7j+c4ur8MR7JswcOBAmc21/xc1dUfYum0REREOmTgLAC1VWl6ttftOyeZn0dxRPZ1dDgB0qJ5dA/Wb24dq1Q/Gadw13XTk9Hk99OrnemhVko7lOGb+ozsg2DfBZrNp/PjxkqRNmzZddh/DMLR582ZJ0tSpUzusNgBo6J2kUyopr9Z3RvZkhQgAXqt/ZGc9f/cI/d93R2lQj2Dt+bpA9/5tp377bqryzpc7u7x2R7C/isWLF0uStm7dqj179lyyfc2aNTpxova27ffee2+H1gYAklRZbdcbuzPkYzFpwdgYZ5cDAE43PDZU/1wyRs/cMUQRwQF6PzlLd7zwmf7x8XGVVVQ7u7x24zXBvqioSPn5+fU/dTeeKisra/R8SUlJo3aLFy/W4MGDZRiG5s2bp8TEREmS3W7XmjVrtGTJEkm1d6adPHlyx74oAJC06WC28osrNH1olMI6+zu7HABwCSaTSTfHR+o/P7leP5naX1aLSf/85Gvd8cKneu/zTNV44ARbk+Eltx2NjY1VRkbGVfdbvHixVqxY0ei59PR0TZo0Senp6ZJqh+jY7XaVl9f+SSchIUGJiYkKCQlxdNltUlpaqqCgIElSSUkJS1sCHshuN3TXX3foZEGp3njwesV0479zALicc2WV+tcnX+utvadUYzfUt3uQHpzaX+OuCXNqXY7Ma17TY98WsbGxSklJ0dNPP634+HiZTCb5+PhoxIgRWr58uXbv3u1yoR6Ad9h+5Iwy8ks1YUB3Qj0ANCHY5quHZwzU6w+O18SB3fX1mRI9/Np+/XRVko7nesYEW6/psfdG9NgDns0wDD3w8h59kXlOLy8Zo/joLs4uCQDcxoGMIr2w+Yi+zDons0m6dURP/ddN/RQS6NuhddBjDwBQckaRvsg8p+GxIYR6AGihYTEh+ueSMfrN7UPUrZO/3kk6pTte+FRv7Ep32zvYEuwBwE29+lmaJOme63s7uRIAcE8mk0lTB0fqzZ9crwcm9lVVjV1/2nREi/5vp1JOFjm7vBYj2AOAGzqWU6xdx/J1TUQnje3XzdnlAIBb8/e16IFJ/fTmT67X1MERyiwsk83P6uyyWsz9KgYA6LUdtb31d4+PlclkcnI1AOAZwoMD9Jvbh+oHky8oKiTA2eW0GD32AOBmsosu6KPUHEV2CdDkuAhnlwMAHscdQ71EsAcAt/PvnemqsRtaeF2MrBbexgEAtfhEAAA3UlRaqfeTM9XF5qPZCdHOLgcA4EII9gDgRt7ac1IVVXbdOSZG/r4WZ5cDAHAhBHsAcBMXKqu1Zu9JBfhaNG90T2eXAwBwMQR7AHATHyRn6fyFKs0Z3kPBto69MyIAwPUR7AHADdTYDb2+K0MWs0nzx8Y6uxwAgAsi2AOAG9h2OFfZRRd006Bwt12GDQDQvgj2AODiDMPQ6os3pFo0Pta5xQAAXBbBHgBcXHJGkb7MOq8RvUM1ICrY2eUAAFwUwR4AXNzqHemS6K0HADSNYA8ALiztTIl2HM1T3+5BGtevm7PLAQC4MII9ALiwf+9MlyQtHB8rk8nk3GIAAC6NYA8ALiq/uEKbUrIV1slPU+MjnV0OAMDFEewBwEWt2ZOhqhpDd46NkY+Vt2sAQNP4pAAAF1RaUa23952Szc+i74yMdnY5AAA3QLAHABf0/v5MFZdX69bh0Qry93F2OQAAN0CwBwAXU11j1xu7MmQxm7RgXIyzywEAuAmCPQC4mI+/zFXOuXLdHB+h8OAAZ5cDAHATBHsAcCGGYei1HWmSuCEVAKBlCPYA4EKS0gp19HSxRvftqmsiOju7HACAGyHYA4ALWb0jXRK99QCAliPYA4CLOJ5brN3H89U/opNG9+nq7HIAAG6GYA8ALuLfF3vrF46Plclkcm4xAAC3Q7AHABdw5ly5Nh86rfBgf02Ji3B2OQAAN0SwBwAX8J89GaqxG5o/NkZWC2/NAICW49MDAJystLxa7yZlKsjfqltHRDu7HACAmyLYA4CTvfv5KZVWVOu2EdEK9LM6uxwAgJsi2AOAE1XX2PXG7gxZLSbNHxvj7HIAAG6MYA8ATvTRFznKO1+hqYMjFdbZ39nlAADcGMEeAJzEMAz9e2e6JGnhdbFOrQUA4P4I9gDgJPvTi3T0dLFG9+2qfuGdnF0OAMDNEewBwEle35UuSbprHGPrAQBtR7AHACc4mV+qz47kqXdYoMb26+bscgAAHoBgDwBO8MbuDEnSgnGxMplMTq4GAOAJCPYA0MHOlVVq/YEshQT6atqQSGeXAwDwEAR7AOhg7yRlqqLKrrmjesrfx+LscgAAHoJgDwAdqLLarjV7MuRrNWvuqJ7OLgcA4EEI9gDQgT5KPa2CkkpNGxKprkF+zi4HAOBBrI44yNGjR7Vr1y5lZ2crLy9P5eXl6tq1q8LCwjRw4ECNHz9eNpvNEacCALdlGIZe31U7afaucbHOLQYA4HFaHex37dqlv//979q0aZPOnDnT9EmsVg0fPlyLFi3SPffco+Dg4NaeFgDcVlJaoY7lFGtsv27q0z3I2eUAADyMyTAMoyUNXnvtNf3hD3/QF198oYZNg4KC1LVrV4WGhiogIECFhYUqLCxUfn6+7HZ77clMJgUEBOiuu+7S008/rZ49GV/ankpLSxUUVBseSkpKFBgY6OSKAO/289c+185j+frzvSM0pi9r1wMAHJvXmt1jv23bNj3yyCNKTk6WYRgKDQ3VvHnzNGHCBI0ZM0b9+vW7bLuSkhIlJSVpz549WrdunXbt2qV//vOfWr16tR566CE9+eST6tSJW6kD8GxpeSXaeSxffbsHaXSfrs4uBwDggZo9efamm27S/v37NXXqVL3zzjs6ffq0XnrpJS1atOiKoV6q7cmfOHGiHn/8ce3YsUMnTpzQsmXLFBgYqD/84Q/605/+5IjX4XHuu+8+mUymK/4sWbLE2SUCaIH/1I2tv44bUgEA2keze+ynTZumZcuWacyYMW06YWxsrJ5++mk98sgj+stf/sLwkCv4/ve/rylTplzy/IoVK5SYmKhbbrnFCVUBaI2i0kptPJit0CBfTR3MDakAAO2jxWPsG6qsrJSvr68j60ET7Ha7YmJiVF5eruzsbPn4+DS5P2PsAdfwr21f6+9bj+u/JvXT9yb2dXY5AAAX4si81qZ17H/4wx+2pTla6KOPPlJmZqbuvvvuq4Z6AK6hoqpGa/aelJ/VrO9wQyoAQDtqU7B/5ZVX9PLLLzuqFlzFK6+8Ikn67ne/6+RKADTXh6k5Kiqt1IyhUQoJ5C+cAID206ZgHxQUpJ/+9Kfav39/s/Y3DEOPPvpoW07ZKmVlZdq4caOeffZZzZ07VzExMfWTUJctW9asYxQXF2vZsmUaPHiwgoKCFBwcrFGjRum5555TZWVl+74ASefOndO7776r4cOHa8iQIe1+PgBtV3tDqnRJ0vxxMc4tBgDg8dp059l//etfuvPOO3X77bcrKSlJoaGhV9y3vLxcixYt0rvvvqs//vGPbTlti+3du1czZ85sdfuMjAxNnDhR6enpkiSbzaaKigolJSUpKSlJq1evVmJiokJCQi5pW1lZqZSUlGadJyAgQHFxcZfd9sYbb6i8vJzeesCN7E8v1Ne5JRrbr6t6h3FDKgBA+2pTsL/99tv105/+VC+88IIWLlyoTZs2XXa/vLw8zZ49W3v37pXNZmvLKVstJCREw4cPr/95+OGHlZOTc9V2NTU1mj17ttLT0xUZGalVq1ZpypQpstvtWrNmjZYsWaLk5GQtWrRIGzZsuKR9dna2Ro0a1awa4+LilJqaetltK1askK+vrxYuXNisYwFwvjd3n5Qk3TmW3noAQPtrU7CXpOXLl2vPnj368MMP9atf/UrPPPNMo+2HDx/WLbfcovT0dIWHh2vdunVtPWWL3XDDDSosLGz03BNPPNGstitWrNChQ4ckSWvXrtW4ceMkSWazWfPnz5fdbtfChQu1ceNGJSYmavLkyY3aR0REaOvWrc0615VmQR85ckS7d+/W7bff3uRfRQC4juyiMm0/cka9uto0lrvMAgA6QJuDvdVq1ZtvvqmEhAT97ne/09ixY+vXWP/44491++236+zZs4qPj9cHH3ygXr16tbnolrJYLK1uu3LlSknSpEmT6kN9QwsWLNBTTz2ltLQ0rVq16pJg7+/vr4kTJ7b6/BKTZgF3tGbPSRmGdOeYGJnN3JAKAND+2jR5tk7Pnj21evVqSdK9996rEydO6JVXXtGMGTN09uxZTZs2TTt27HBKqG+LsrIy7dixQ5I0Y8aMy+5jMpk0ffp0SdKWLVscXoPdbtdrr72myMhITZs2zeHHB+B4ZRXVej85S4F+Vs0YFuXscgAAXqLZPfbTp0/XiBEjNGLECA0fPlyxsbGNtk+bNk1PPfWUnnnmGV133XXKy8uTYRj68Y9/rD//+c8ymx3yHaJDHT58WHa7XZIUHx9/xf3qtuXk5KiwsNChw2W2bNmirKwsPf744236y0NpaekVt3HjKsCxNhzIVkl5tRaMi1GgX5v/MAoAQLM0+xNny5Yt+vDDD+t/bzgZtS7wL126VLt27dJHH30ks9ms559/Xj/96U/bpfCOkJ2dXf+4R48eV9yv4bbs7GyHBvsVK1ZIku677742HSc8PPyK29pw82EA32K3G3pzT4ZMJumO0e71V0oAgHtrdrD/xS9+oeTkZCUnJys3N1eFhYX66KOPlJiYWL9P586d1atXL5lMJi1cuFBTp06VYRgymdxzfGlxcXH946ZW82m4rWEbR3jjjTf0xhtvOPSYANrPnq/zdbKgTBMGdFePUOesAgYA8E7NDva//e1v6x9nZ2dr//79jX4yMzN17ty5+hVkVq9erdWrVysgIECDBw/WsGHDlJCQoGHDhmn06NGOfyVoUm5uLkNugA7wn4tLXM4fS289AKBjtWrwZ1RUlKKiojRr1qz65woKCi4J+ydOnFBZWZn27NmjvXv3SqqdbFpdXe2Y6ttZp06d6h+XlZVdcb+G2xq2cSWBgYEEe6CdpeeVaPfxfPXtHqThsSxNCwDoWA6b1dW1a1fdfPPNuvnmm+ufO3/+vJKTk+uD/ueff65jx4456pTtLirqm9UssrKyNGTIkMvul5WVddk2ALzLmj3f3JDKXYcgAgDcV7su19C5c2fdeOONuvHGG+ufu3DhQnue0qEGDhwos9ksu92u1NTUKy55WXe32IiICG4gBXip4gtV2nAwW8E2H00bEunscgAAXqjD16AMCAjo6FO2ms1m0/jx4yVJmzZtuuw+hmFo8+bNkqSpU6d2WG0AXMu6/Vm6UFmj20ZEy9+n9UvTAgDQWu63uHwHW7x4sSRp69at2rNnzyXb16xZoxMnTkiqvTkXAO9TYzf01t6TsphNmjeKSbMAAOdodrBfvny5w4fR7Nu3Txs3bnToMa+kqKhI+fn59T91N54qKytr9HxJSUmjdosXL9bgwYNlGIbmzZtXv7yn3W7XmjVrtGTJEkm1d6adPHlyh7wWAK5lx9E8nT57QRMHhqt7sL+zywEAeKlmB/vHHntMffr00fPPP6+zZ8+26aSfffaZZs2apbFjx2rfvn1tOlZzJSQkKCwsrP7n1KlTkqQ//vGPjZ5/8MEHG7WzWq1at26dYmNjlZWVpSlTptSvMHPnnXfq/PnzSkhI0OrVqzvkdQBwPWv31k6avWMMvfUAAOdpdrB/8skndf78eT3yyCOKjIzU7bffrrVr1+rMmTNXbVtVVaV9+/bpV7/6lfr27asbb7xRGzZs0KhRo3Tbbbe1pf4OERsbq5SUFD399NOKj4+XyWSSj4+PRowYoeXLl2v37t0KCQlxdpkAnOBkfqn2fF2gvuFBGtqri7PLAQB4MZNhGEZzd87KytKTTz6pf//736qpqalfzq1nz54aOnSowsLCFBoaKj8/PxUVFamwsFAnTpzQwYMHVVlZKal2smnfvn31zDPPaMGCBe3zqiBJKi0tVVBQkCSppKSEdeyBdvCnTV/pjV0ZenzWIH1nVE9nlwMAcDOOzGstCvZ1srOz9fe//13/+te/lJmZ+c3BLrNuc93hrVarbrnlFn3/+9/XtGnTWOO5AxDsgfZVXlmj2c9tk92Q3v/vG2Xza9cVhAEAHsjpwb6h1NRUbd++XXv27FF2drby8vJUXl6url27KiwsTIMGDdKECRM0fvx4l70rq6ci2APta93nmfqfdV/ojjG99N8zBzq7HACAG3JkXmtz91J8fLzi4+P1ox/9qK2HAgC3YRiG3tpXO2l2HkNwAAAugHXsAaAVUjPP6ejpYo3sHarYsCBnlwMAAMEeAFqjbonLeaNZ4hIA4BqcFuwrKysdfsMrAOgIhSUVSvwiR2Gd/XTDtWHOLgcAAElODPbV1dX61a9+pZqaGmeVAACt8kFylqpqDH1nRE9ZLfzhEwDgGtrtE+n48eP63//9X7366qsqKSm5ZLvNZtMtt9yi3/72t+1VAgA4XI3d0NtJp2Qxm3TriGhnlwMAQL02L3d5Ofn5+br22mt19uxZGYahXr16KTExUX379m2037lz59SvXz/l5eU5ugSI5S6B9rD9qzN67PVkTYmP0LN3DHV2OQAAN+fIvNYuPfZvvfWWOnfurL/85S968cUXZbVatXDhwkb75Obm6pFHHrlsbz4AuKq3Ly5xeTuTZgEALqZdbpO4d+9erVy5UhMmTJAkzZ07V2PGjNHmzZvVr18//eAHP9DWrVtlGIYeeuih9igBABwuu6hMu48XqG/3IA3t1cXZ5QAA0Ei7BPusrCyNGDGi/vewsDD94Q9/0N///nft379fGRkZGjFihB555BHNnz+/PUoAAIdbtz9LkjRnRLRMJpOTqwEAoLF2CfYlJSXy9/dv9Nztt9+un/70pzKbzVq/fr1mzJjRHqcGgHZRXWPX+uQs+VnNmj4k0tnlAABwiXYZY19dXa1Jkybp//7v/5SWllb//HXXXae33nqLUA/A7ew8lq+84gpNGhSuYJuvs8sBAOAS7dJjb7Va9dlnn2nHjh2SpP79+2vmzJm66667Gg3RAQB38d7nmZLEEpcAAJfVLstdzp49W+Hh4erbt68+/PBD7dy5U5WVlTKZTAoMDNTNN9+suXPnav78+bJa2+W7BcRyl4CjnDlXrtue/0Q9uwbqjQfHM74eAOAwLr/c5eDBg7Vo0SL94he/0Mcff6yCggK98847euCBBxQaGqp33nlH9957r4YOHaqTJ0+2RwkA4DDvJ2fKbkhzhjNpFgDgutol2N9zzz3atm1b/e+BgYG69dZb9dJLLyk9PV2pqan6/e9/r8DAQD3yyCPtUQIAOESN3dC6/VmyWkyaOSzK2eUAAHBFrRoHU1lZqb/+9a86cOCALBaLBg4cqLvuukvR0bVjTwcOHKiKigqlp6crNjb2kvaDBg3SoEGD9Oijj+p3v/tdm14AALSnPV/nK/dcuabERygkkEmzAADX1aox9pMnT27UIy9Jfn5+Wrp0qR5//HFJkt1uV05OjqKi6OFyFsbYA233+BvJ+uTwGf2/xSM1qk9XZ5cDAPAwTh1jv2nTpvq7xnbp0kXdunWTJJWXl+vJJ5/Uf//3f9ce2Gwm1ANwa/nFFfrsSJ56hARoRGyos8sBAKBJLQ72GzZsUPfu3fXZZ5+poKBAubm5OnPmjJ5//nl16dJFf/rTn7Rp06b2qBUAOtSGA1mqsRu6dUS0zGYmzQIAXFuLg/3Bgwe1bNkyXXfddfXPde3aVQ899JD27NmjHj166Fe/+pVDiwSAjmYYhj5IzpLZJM0c1sPZ5QAAcFUtDvaZmZm6+eabL7utX79+evPNN3XgwAF99dVXbS4OAJzli8xzOllQprH9uqlbJz9nlwMAwFW1ONjn5+fXr35zOWPHjtWdd96pLVu2tKkwAHCm9QeyJNFbDwBwHy0O9hUVFVfd5/7771dycnKrCgIAZ6uoqtGHqTnq5G/VDdeGObscAACapcXBvrKyUnfccYc2bNig8vLyy+4zYcIE5ebmtrk4AHCG7UfOqKS8WlPiI+XnY3F2OQAANEur7jy7fv16zZ49WyEhIZo6daqWL1+uQ4cO1W+3Wq0KDw93WJEA0JE2HMiWJN3CnWYBAG6kxTeoMpvNMplMqmtmMn2zBFxERISmTp2qadOmafz48erZs6djq0WLcIMqoOXyiys057lt6tk1UG88OL7RexwAAI7myLxmbWmD0NBQRUdHa8GCBUpJSdG2bduUk5MjSTp9+rRWrVqlVatWyWQyafjw4Zo2bZqmTZum66+/vtVFAkBH2XQwW3ZDmjk0ilAPAHArLe6xHz16tO677z796Ec/qn8uNTVVGzZs0MaNG7Vz505VVVXVHrzBh2L//v31wgsvXHGpTDgePfZAyxiGoUX/t1NpeSV67+Eb1T3Y39klAQA8nCPzWovH2M+aNUvp6emNnouPj9djjz2mrVu3Kj8/X2+99Zbuv/9+RUVFyTAMGYahI0eO6NZbb2W1HAAu68jp8zpxpkSj+nQl1AMA3E6Lg/13v/td7dy584rbO3XqpLlz5+of//iHTp06pQMHDuh//ud/NHLkSJWXl+t///d/21QwALSXTSmnJUkzhjJpFgDgfloc7Hv27KnJkydr9erVzdp/yJAheuKJJ7R3715t2bKFHnsALqnGbuij1Bz5Wc2aMKC7s8sBAKDFWrXc5dKlS7Vu3TpduHChRe2mTJmihx56qDWnBIB2dSCjUPnFFbr+2u4K9GvxugIAADhdqz69zGaz/vOf/7TqhEuWLGlVOwBoT5svDsOZOjjCyZUAANA6reqxBwBPUlVt17bDuQryt2rcNWHOLgcAgFYh2APweru/ztf5C9WaNDBcvlbeFgEA7olPMABeb8vFYTg3D450ciUAALQewR6AV7tQWa1Pj+QpNMhXI3qHOrscAABajWAPwKvtPJav8qoaTY6LkMVsunoDAABcFMEegFfb+mWuJGnSoHAnVwIAQNsQ7AF4rYqqGu08mqeQQF8N7RXi7HIAAGgTgj0Ar7Xn6wKVVdZo4sDuDMMBALg9gj0Ar7Xt4jCciQzDAQB4AII9AK9UVW3Xp0fOqHOAVSNiWQ0HAOD+CPYAvNLn6YUqLq/WDdd2l9XCWyEAwP3xaQbAK7EaDgDA0xDsXdipU6e0ePFihYeHy8/PT4MGDdILL7wgwzCcXRrg1mrshrZ/dUY2P4tG9+3m7HIAAHAIq7MLwOVlZ2drzJgxKiws1I9//GNdc8012r59ux566CGdPHlSy5cvd3aJgNs6nHVORaWVmhwXLl8r/RsAAM9AsHdRv/vd73T69Gm99dZbmjdvniTpBz/4gcLDw/X888/rgQce0IABA5xcJeCedhzNkyRd1z/MyZUAAOA4dFW5qO3btysgIEBz585t9PyiRYtkt9v1+uuvO6kywP3tOJYnk0ka149hOAAAz0Gwd1EVFRUKCAiQydT4pjk2m02StG/fPmeUBbi9M+fLdfR0sQZGBSs0yM/Z5QAA4DBeEezLysq0ceNGPfvss5o7d65iYmJkMplkMpm0bNmyZh2juLhYy5Yt0+DBgxUUFKTg4GCNGjVKzz33nCorKx1e84ABA1RYWKjU1NRGz3/yySeSpMzMTIefE/AGOy8Owxnfn956AIBn8Yox9nv37tXMmTNb3T4jI0MTJ05Uenq6pNpe84qKCiUlJSkpKUmrV69WYmKiQkJCLmlbWVmplJSUZp0nICBAcXFxkqQHH3xQ69at0/z58/XCCy+oX79++vTTT/XLX/5SVqtVZWVlrX49gDfbeSxfkjS+f3cnVwIAgGN5RbCXpJCQEA0fPrz+5+GHH1ZOTs5V29XU1Gj27NlKT09XZGSkVq1apSlTpshut2vNmjVasmSJkpOTtWjRIm3YsOGS9tnZ2Ro1alSzaoyLi6vvoZ8yZYpefvllPfLII5oyZYqk2uC/fPlyLVu2TJ06dWrBqwcgSZXVdu07UaBunfx0bST/DQEAPItXBPsbbrhBhYWFjZ574oknmtV2xYoVOnTokCRp7dq1GjdunCTJbDZr/vz5stvtWrhwoTZu3KjExERNnjy5UfuIiAht3bq1WecKDAxs9Pv3vvc93X333UpJSVFlZaXi4+NltVr1k5/8RJMmTWrWMQF8Izm9UBcqazQlPuKS+SsAALg7rwj2Foul1W1XrlwpSZo0aVJ9qG9owYIFeuqpp5SWlqZVq1ZdEuz9/f01ceLEVp/f19dXI0eOrP/9vffek91u17Rp01p9TMBb7agfX88ylwAAz+MVk2dbq6ysTDt27JAkzZgx47L7mEwmTZ8+XZK0ZcuWdq2nuLhYv/zlL9WrVy8tWLCgRW1LS0uv+AN4i93H82W1mDSqT1dnlwIAgMN5RY99ax0+fFh2u12SFB8ff8X96rbl5OSosLBQoaGhbT53SUmJxo4dW7+KT05Ojv75z38qLy9Pmzdvrl/2srnCw8OvuM0wjLaWC7i83HMXdLKgTAkxIQr0460PAOB5+HRrQnZ2dv3jHj16XHG/htuys7MdEux9fX0VFxenFStWKDc3V126dNGUKVO0dOlS9e/fv83HB7zNvhO182xG9mn7f58AALgign0TiouL6x831UPecFvDNm3h6+ur//znPw45liTl5uZeMjkX8Cb7ThRIkkYyDAcA4KEI9l4iMDCQYA+vZRiGkk4UyOZrUVyPYGeXAwBAuyDYN6HhWvFN3RCq4TZvXl/+zPly/e2jY/LzMcvPxyL/+h+z/KwW+fta5Odjlr+Ppfb3i4/rfuq2WS3M6YZjpeWVqqCkUuP7h3F9AQA8FsG+CVFRUfWPs7KyNGTIkMvul5WVddk23qawpFIbDmZffcersJhNjYJ+wy8Hfj6NvxDUf1Go+91qlr9vgy8L1obbG+/rYzGxlrmXqBuGM4rx9QAAD0awb8LAgQNlNptlt9uVmpp6xSUv6+4WGxER4ZCJs+4qNixQr/7wOlVU16iiqkblVXaVV9WovKpGFY0eN/69vKpGFdX2+m117SqqanSurEq5VeWqsTt+5R6zSfVB3+/bfz341heCui8DAb4W2S5+cbD5WRXga1FA/fNW+V/cHuBr5YuDC/k8rXbi7IjejK8HAHgugn0TbDabxo8fr08//VSbNm3So48+esk+hmFo8+bNkqSpU6d2dIkuxd/Homsi2mcoUnWN/ZIvAw2/ENR9eaio39b4i0LFFdvUtistr1ZBcYWqahz3BcJiNtUG//rwb63/ve7LQYCvtfZxgy8ENl+LAv2sCvS3qpO/j4L8rAryr23LF4WWs9sNHTxZpM4BVvXtHuTscgAAaDcE+6tYvHixPv30U23dulV79uzRmDFjGm1fs2aNTpw4IUm69957nVGiV7BazLJazAr0b99LtsZuNPpyUNHgy8CFympdqKrRhcoaXaioufi4uvb3yhqVVdbuW1ZZrfJvPZd7oVwVVfY21WYxmxToZ1HQxbD/7eAfbPNRF5uvQoJ8FWLzVUhg7U8nfx+Zzd77hSCjoFTnyqp0/bVhXv3/AwDA83lNsC8qKlJNTU3973U3niorK1N+fn798/7+/goK+qZXb/Hixfrzn/+sQ4cOad68eVq5cqUmT54su92utWvXasmSJZJq70w7efLkDno1aC8Ws0k2P6ts7XADoxq7ofK6LwYXvxA0/DJQ/wWholqlFTUqrahScXm1SsqrVVJepZKK2sfnyqqUXXShRa8p2OajEJuvQoP8FB7sX/vT2V/hXfwVERyg8M7+8ve1OPw1u4KDGUWSpKG9QpxcCQAA7ctkeMltR2NjY5WRkXHV/RYvXqwVK1Y0ei49PV2TJk1Senq6pNohOna7XeXl5ZKkhIQEJSYmKiTEtYJDaWlp/ZeUkpISlrv0IDV2Q2UV1RfDfu0XgHNlVSoqrdTZ0koVllbqbFnt46LSShVdfNzUVIVunfwU2y1QMd0CFRsWqJhuQeodFqhunfzcegjQb94+pA0Hs/X3+0drCOEeAOBiHJnXvKbHvi1iY2OVkpKi5cuX6+2331ZaWpp8fHwUFxenu+66Sz/5yU/k6+vr7DLhRSxmkzoF+KhTgI+kgGa1sdsNFZVV6sy5cuWcK7/4vxeUe/F/TxaUKSmtUEkXJ5rW6dbJT4N6BNf/xPUIbvchUY508GSRfK1mDYhi/XoAgGfzmh57b0SPPVrCMAwVllQqPb9UGfmlSs8r0ddnSnQ4+5zKKr4ZxmYxmxQXHayxfbtpTL+uGhAVLIuLjl3PO1+u2c99omExIfrb90Y7uxwAAC5Bjz0AhzOZTOrayU9dO/lpRO9vlm212w1lFJTqi8xz+iLznJIzCpVy8qxSTp7V37ceV7dOfpocF66bB0cqrkewSw3bSTl1VpI0tFcXp9YBAEBHINgDaJLZbFLvsCD1DgvSrIQekqScsxe05+sC7T6er53H8vSf3Sf1n90n1ad7kG4f3UszhkYqwNf5by8pJ2snzjK2HgDgDRiK48EYioOOUFZRrU+PnNHGg6e1+3jtClNB/lbdNS5GC8bFKrAdVhhqriUv79GhU2e16bFJ6hLIPBgAgOthKA4Al2Hzs2rakChNGxKlUwWlWrv3lNYlZ+ofW7/WW3tP6b4b+mje6J6yWswdWld1jV3HcooV0cWfUA8A8Aod+0kLwKP17Bqon80YoLcfmqC7xsWotKJaz2/6St/9+24dzjrXobVk5JeqvKpGA1kNBwDgJQj2AByuS6CvHpo+QG/+5HpNHNhdx3KK9cDLe7Tq0xOyN7WYvgMdzj4vSRoY1blDzgcAgLMR7AG0m4guAfr9ggT9bv4wBfpZ9X8fHdOjryertKK63c/9VXbtXwhYvx4A4C0I9gDa3aRB4Vr1g3GKjw7WjqN5+tEr+1RQXNGu56zrsR9Ajz0AwEsQ7AF0iIguAfrrfaM0aVC4jpw+r+//a2+7hfu6ibPRoQHqHODTLucAAMDVEOwBdBg/H4uevWOobh0RrczCMv301SSdv1Dl8POcOFOiymo7w3AAAF6FYA+gQ1nMJj02a5Bujo/Q17kleuz1ZFXX2B16jvphOJEMwwEAeA+CPYAOZzGbtHTuYI3q01UHMor04kfHHHr8E2eKJUnXRHRy6HEBAHBlBHsATmG1mPWb24eoe2d/rd6Zrk8O5zrs2CfOlEqSencPctgxAQBwdQR7AE4TEuir/7lzqCxmk37//pcOG2+fnleiIH+rwjr5OeR4AAC4A4I9AKeK79lFd42LUVFppV786Gibj1d8oUp5xRXqHRYkk8nkgAoBAHAPBHsATnf/xL6K7BKgd5IylXKyqE3HSssrkST1Dgt0RGkAALgNgj0ApwvwteqRWwZKUpsn0qblXRxfH8b4egCAdyHYA3AJ113TTUN6dVFyRpH2pxe2+jhpZ2p77PswcRYA4GUI9gBcgslk0v039pUk/Wvb160+zjdDcQj2AADvQrAH4DJG9+2quOhgJaUV6mArx9qfyCtRoJ9VYZ1ZEQcA4F0I9gBchslk0n0T+kiS1uw52eL2JeVVyjtfod5hgayIAwDwOgR7AC7lumvCFNHFX9sO56qgpKJFbesnzjK+HgDghQj2AFyKxWzSrcOjVV1jaNPB7Ba1zcivDfax3VjqEgDgfQj2AFzOjKFRkqTNh063qF1WYZkkKTrU5vCaAABwdQR7AC4nokuAhvbqoqOni+tXuWmOrKILkqQeBHsAgBci2ANwSTfHR0qSPjl8ptltsopqe+yjugS0S00AALgygj0Al3T9tWGSpB1H85rdJquwTKFBvrL5WdurLAAAXBbBHoBLiugSoGsiOik186wKm7E6Tml5tc6WValHCMNwAADeiWAPwGWN7x8mw5D2nSi46r51w3CYOAsA8FYEewAua2TvUEnS52mFV9339NnaibORXfzbtSYAAFwVwR6Ay4rv2UU+FpP2p1892OeeK5ckhQczcRYA4J0I9gBclr+PRfHRXZRZeEG55y40ue83wZ4eewCAdyLYA3BpQ2NCJEmpmeea3C/3/MVg35lgDwDwTgR7AC5tUI9gSdKXWVcJ9hd77LvTYw8A8FIEewAurbnB/sz5cgX5WxXIGvYAAC9FsAfg0rp18lNYZz8dyT6vGrtx2X2qa+zKL65gGA4AwKsR7AG4vEFRwSqrrNGpgtLLbi8oqVCN3WAYDgDAqxHsAbi8vuFBkqQTeSWX3Z53vvbOtN3psQcAeDGCPQCX1zusNtinn7lyj70kdQ3y7bCaAABwNQR7AC6vd/eme+wLSyolSaGBfh1WEwAAroZgD8Dl9eoaKIvZpLQzVwj2pbU99qH02AMAvBjBHoDL87WaFR1qU0ZBqapr7Jdsr++xD6LHHgDgvQj2ANxCr642VdcYyrl4I6qGCkvrhuLQYw8A8F4EewBuISokQJJ0+uyFS7YVljAUBwAAgj0AtxDVxSZJyi66TLAvrZSv1cxdZwEAXo1gD8AtRDbZY1+p0EBfmUymji4LAACXQbAH4BYiu9QG+2/32FdU1ai0opphOAAAr0ew70AlJSVatmyZZs2apYiICJlMJt13331t3hfwBlFdLt9jX3Rx4mwIa9gDALwcwb4D5efn69e//rX279+vkSNHOmxfwBsE+lvVOcDnkmB/7kKVJKmLzccZZQEA4DKYadaBIiMjlZmZqR49eqi8vFwBAQEO2RfwFpFdAnTk9HlVVtvla63tlygprw32nfwJ9gAA70aPfQfy8/NTjx49HL4v4C26XhxHX3TxTrOSdP5CtSSpUwD9FAAA70awB+A26u4sW3enWUkqvkCPPQAAkhsH+7KyMm3cuFHPPvus5s6dq5iYGJlMJplMJi1btqxZxyguLtayZcs0ePBgBQUFKTg4WKNGjdJzzz2nysrKqx8AQIequ7Ns3Z1mJam4vK7HnmAPAPBubvu3671792rmzJmtbp+RkaGJEycqPT1dkmSz2VRRUaGkpCQlJSVp9erVSkxMVEhIyCVtKysrlZKS0qzzBAQEKC4urtV1AvhGaP1QnIbBvq7H3m3fzgAAcAi3/iQMCQnR8OHD638efvhh5eTkXLVdTU2NZs+erfT0dEVGRmrVqlWaMmWK7Ha71qxZoyVLlig5OVmLFi3Shg0bLmmfnZ2tUaNGNavGuLg4paamtvi1AbjUN0NxvhljXzd5NoihOAAAL+e2wf6GG25QYWFho+eeeOKJZrVdsWKFDh06JElau3atxo0bJ0kym82aP3++7Ha7Fi5cqI0bNyoxMVGTJ09u1D4iIkJbt25t1rkCAwObtR+Aq6sfitNgjH3d5NnODMUBAHg5tw32Foul1W1XrlwpSZo0aVJ9qG9owYIFeuqpp5SWlqZVq1ZdEuz9/f01ceLEVp8fQOvU99g3WBWnuL7H3m3fzgAAcAi3nTzbWmVlZdqxY4ckacaMGZfdx2Qyafr06ZKkLVu2dFhtAJp2uR77kouTZzszFAcA4OW8rovr8OHDstvtkqT4+Pgr7le3LScnR4WFhQoNDXXI+f/yl7/o7Nmzqq6uDSMpKSl69tlnJUkTJkzQhAkTWrXv1ZSWll5xG8OF4C46B/jIYjY1WhXn/IUq+VhM8vPxun4KAAAa8bpgn52dXf+4qRtANdyWnZ3tsGC/fPlyZWRk1P+enJys5ORkSdLSpUsbhfWW7Hs14eHhV9xmGEazjwM4k9lsUkig7yWTZ4P8fWQymZxYGQAAzud1wb64uLj+sc1mu+J+Dbc1bNNWdctrOnpfwFsE23yUdqZEhmHIZDKpuLxakV0CnF0WAABO53XB3lvl5uYy5AYeIdDPKrshlVfVyGwyqbLazsRZAADkhcG+U6dO9Y/LysquuF/DbQ3buKvAwECCPTxCoF/t21ZpRY3qRt8E+XndWxkAAJfwutlmUVFR9Y+zsrKuuF/DbQ3bAHCub4J9tSqqaiRJ/r6tX/4WAABP4XXBfuDAgTKba192U3eErdsWERHhsImzANquYbAvr6pd4crfh2APAIDXBXubzabx48dLkjZt2nTZfQzD0ObNmyVJU6dO7bDaAFzd5Xrs/axe91YGAMAlvPLTcPHixZKkrVu3as+ePZdsX7NmjU6cOCFJuvfeezu0NgBNqxtPX1JerfK6oTj02AMA4N7BvqioSPn5+fU/dTeeKisra/R8SUlJo3aLFy/W4MGDZRiG5s2bp8TEREmS3W7XmjVrtGTJEkm1d6adPHlyx74oAE1qPBTnYo89wR4AAPcO9gkJCQoLC6v/OXXqlCTpj3/8Y6PnH3zwwUbtrFar1q1bp9jYWGVlZWnKlCn1q8bceeedOn/+vBISErR69WpnvCwATQj0bzAUp7pujL1bv5UBAOAQXvtpGBsbq5SUFD399NOKj4+XyWSSj4+PRowYoeXLl2v37t0KCQlxdpkAvsXmV9s737DHnqE4AAC4+Tr2bb0za6dOnfTrX/9av/71rx1TEIB213jybG2PvZ+VYA8AgNf22ANwT3XBvqxhjz3r2AMAQLAH4F5Y7hIAgMvj0xCAWwlssNxl/VAcxtgDAECwB+Begi6z3CWTZwEAINgDcDMBvhaZTHXLXdatY89bGQAAfBoCcCsmk0mBflaVVFSrvKpuHXt67AEAINgDcDv+PhZVVNm/ufMsk2cBACDYA3A/Phazqmrs9avi0GMPAADBHoAb8rWaVVVtZygOAAANEOwBuB0fi0mVNQ2G4jB5FgAAgj0A9+NjMcswau8+K0l+VnrsAQAg2ANwOz4XJ8sWl1fLz2qW2WxyckUAADgfwR6A2/G11AX7KobhAABwEZ+IANxOXY/9hcoa+TFxFgAASQR7AG6orsdeYnw9AAB1CPYA3I61QbD3ZygOAACSCPYA3JCvtWGwp8ceAACJYA/ADflYvlkFhzH2AADUItgDcDv02AMAcCmCPQC349No8ixvYwAASAR7AG7Ix0KPPQAA30awB+B2fBr00jPGHgCAWgR7AG6n0Tr2LHcJAIAkgj0AN+TD5FkAAC5BsAfgdhotd8nkWQAAJBHsAbghJs8CAHApgj0At8M69gAAXIpgD8DtNF4Vh7cxAAAkgj0AN+TLUBwAAC5BsAfgdhhjDwDApQj2ANwOQ3EAALgUn4gA3I6PhTvPAgDwbQR7AG6n4ao4flaCPQAAEsEegBtqPMaetzEAACSCPQA31PDOs0yeBQCgFsEegNtpNBSHYA8AgCSCPQA3xHKXAABcimAPwO3U9dibTI2H5QAA4M0I9gDcTl2Pvb+PRSYTwR4AAIlgD8ANNQz2AACgFsEegNuxXhx+42flLQwAgDp8KgJwOyaTSZ0DfBRs83V2KQAAuAyrswsAgNb437uHK9CXtzAAAOrwqQjALcVHd3F2CQAAuBSG4gAAAAAegGAPAAAAeACCPQAAAOABCPYAAACAByDYAwAAAB6AYA8AAAB4AII9AAAA4AEI9gAAAIAHINgDrVBaWiqTySSTyaTS0lJnlwMn4BqAxHWAWlwHkFzjOiDYAwAAAB6AYA8AAAB4AII9AAAA4AEI9gAAAIAHINgDAAAAHsDq7ALQfgzDqH/MLH3Havj/J//feieuAUhcB6jFdQCp9ddBw30bZrfWMBltPQJc1pkzZxQeHu7sMgAAANAMubm56t69e6vbMxQHAAAA8AD02Hswu92u/Px8SZLNZpPJZHJyRQAAAGjIMAyVlZVJkrp16yazufX97gR7AAAAwAMwFAcAAADwAAR7AAAAwAMQ7AEAAAAPQLAHXMDJkyd19913a8CAAercubOCgoIUHx+v3/zmNyouLnZ2eeggJSUlWrZsmWbNmqWIiAiZTCbdd999zi4L7YB/a0i896NWenq6TCbTZX9a+r7ADaoAF5Cbm6vMzEx95zvfUc+ePWWxWJSUlKRnn31W69at065du+Tj4+PsMtHO8vPz9etf/1qRkZEaOXKk1q9f7+yS0E74t4bEez8amzVrlubPn9/oub59+7boGAR7wAWMGjVK27Zta/Tc97//ffXv31+PPfaYPvzwQ82cOdM5xaHDREZGKjMzUz169FB5ebkCAgKcXRLaCf/WkHjvR2NxcXG6++6723QMhuIALiw2NlaSVFRU5NxC0CH8/PzUo0cPZ5eBDsC/NZrCe7/3Ki8v14ULF1rdnmAPuJDy8nLl5+fr1KlTev/99/WLX/xC/v7+mjBhgrNLAwC0E977IUl//etfZbPZZLPZ1LdvXz3//PNq6e2mCPbwOGVlZdq4caOeffZZzZ07VzExMfWTUJYtW9asYxQXF2vZsmUaPHiwgoKCFBwcrFGjRum5555TZWVlu9X+8ssvKywsTL169dKcOXPk6+ur9957Tz179my3c3oqd74O0DG4RiC5xnXAe7/zOfM6MJvNmjx5sn73u9/pvffe00svvaTQ0FD9/Oc/149//OMWvQ7G2MPj7N27t01jEjMyMjRx4kSlp6dLkmw2myoqKpSUlKSkpCStXr1aiYmJCgkJuaRtZWWlUlJSmnWegIAAxcXFNXrutttu04ABA3Tu3Dnt3LlTH3/8sc6fP9/q1+LN3Pk6QMdw5jUC1+EK1wHv/c7nzOugV69e+uijjxo9d//99+umm27Siy++qB//+MfN/5wwAA+zdetWIyQkxJg8ebLx6KOPGq+//roRERFhSDKWLl3aZNvq6mpj8ODBhiQjMjLS+PDDDw3DMIyamhrjjTfeMDp16mRIMmbMmHHZ9mlpaYakZv3ExcVd9bW8+eabhqT6OtB87n4dXLhwwZBkLF68uC3/N6AJzrxGGuLf2rlc5TpoiPf+jueK18H69esNScaf/vSnZrehxx4e54YbblBhYWGj55544olmtV2xYoUOHTokSVq7dq3GjRsnqfbPZPPnz5fdbtfChQu1ceNGJSYmavLkyY3aR0REaOvWrc06V2Bg4FX3mTt3rvz9/fXKK69oypQpzTouannSdYD24cxrBK7DFa8D3vs7niteB3WTqAsKCpr5KhiKAw9ksVha3XblypWSpEmTJtX/h9nQggUL9NRTTyktLU2rVq265D9Of39/TZw4sdXn/7bq6mpVV1ezMkIreNJ1gPbhzGsErsMVrwPe+zueK14Hx48flySFh4c3uxYmzwIXlZWVaceOHZKkGTNmXHYfk8mk6dOnS5K2bNnisHPn5uZe9vmXXnpJ1dXVGjNmjMPOhaY58zqAe+AageSY64D3fvfniOvg238pkGpXSnrmmWdksVjq2zYHPfbARYcPH5bdbpckxcfHX3G/um05OTkqLCxUaGhom8/9+OOP68svv9TNN9+smJgYlZSUaPv27Vq3bp2uvfZaPfTQQ20+B5rHmdeBJP3lL3/R2bNnVV1dLUlKSUnRs88+K0maMGECy9+5AEddI/xbuzdHXAe897s/R1wHDzzwgEpLSzVu3DhFR0fr9OnTWrVqlY4fP66lS5e26O6zBHvgouzs7PrHTd04puG27OxshwS6uXPnqqCgQCtXrlReXp6sVqv69eunX/7yl3rkkUfUuXPnNp8DzePM60CSli9froyMjPrfk5OTlZycLElaunQpYc8FOOoa4d/avTniOuC93/054jq45ZZbtHLlSr344osqLCxUYGCghg8frt///veaN29ei+oh2AMXFRcX1z+22WxX3K/htoZt2mLOnDmaM2eOQ46FtnHmdSCpfqk0uC5HXSP8W7s3R1wHvPe7P0dcB/fff7/uv/9+h9TDGHsAAADAAxDsgYs6depU/7isrOyK+zXc1rANPAPXAa6GawQS1wFqudp1QLAHLoqKiqp/nJWVdcX9Gm5r2AaegesAV8M1AonrALVc7Tog2AMXDRw4UGZz7X8SqampV9yvbltERITDJkzCdXAd4Gq4RiBxHaCWq10HBHvgIpvNpvHjx0uSNm3adNl9DMPQ5s2bJUlTp07tsNrQcbgOcDVcI5C4DlDL1a4Dgj3QwOLFiyVJW7du1Z49ey7ZvmbNGp04cUKSdO+993Zobeg4XAe4Gq4RSFwHqOVK1wHBHh6pqKhI+fn59T91N48oKytr9HxJSUmjdosXL9bgwYNlGIbmzZunxMRESZLdbteaNWu0ZMkSSbV3l+MW8a6P6wBXwzUCiesAtTziOjAADxQTE2NIuurP4sWLL2mblpZmxMbG1u9js9kMf3//+t8TEhKMwsLCjn9RaDGuA1wN1wgMg+sAtTzhOqDHHviW2NhYpaSk6Omnn1Z8fLxMJpN8fHw0YsQILV++XLt371ZISIizy0Q74zrA1XCNQOI6QC1XuQ5MhmEY7X4WAAAAAO2KHnsAAADAAxDsAQAAAA9AsAcAAAA8AMEeAAAA8AAEewAAAMADEOwBAAAAD0CwBwAAADwAwR4AAADwAAR7AAAAwAMQ7AEAAAAPQLAHAAAAPADBHgAAAPAABHsAAADAAxDsAQDt6qmnnpLJZNLUqVPd4rgA4K4I9gCAdrV//35J0ogRI1rVftiwYTKZTEpMTHTocQHA0xDsAQDtKjk5WVLrAnhGRoYOHjyoLl26aMKECQ47LgB4IoI9AKDdZGVlKTc3V5I0fPjwFrd/7733JEkzZ86Uj4+Pw44LAJ6IYA8AaDd1w2VCQkLUp0+fFrevC/a33nqrQ48LAJ6IYA8AaDd1AfxKvepvvfWWOnfuLJPJpO9+97sqLy+v31ZUVKTt27fL19dX06dPd9hxAcBTEewBAO3mSgG8qqpKP/vZz3THHXeosrJSf/vb3/TKK6/I39+/fp/169erurpaN910kzp37uyw4wKAp7I6uwAAgOe63Mo1p06d0p133qndu3erV69eeuuttzRq1KhL2l5pGE5bjwsAnspkGIbh7CIAAJ4nPz9fYWFhkqRjx46pX79+2rx5sxYtWqSCggJNmTJFr7/+urp163ZJ24qKCnXr1k2lpaXKzMxUVFSUQ44LAJ6MoTgAgHZR16veuXNn9e7dW0uXLtXMmTNVWFioX/ziF9q8efMVw/fHH3+skpISjRw5slGob+txAcCTMRQHANAu6gJ4r169NH36dH300UcKDg7WqlWrNGfOnCbbvvvuu5KaHobTkuOaTKZm1XzjjTdq27ZtzdoXAFwNwR4A0C7qAnhqaqpSU1MVFhamnTt3ql+/fk22MwxD77//viTptttuc8hxX3311Ua/v/3223rnnXf05JNPauDAgfXPh4eHN+u1AYArItgDANpFXQBftGiRXn/9deXl5emTTz65arDfu3evTp8+rb59+youLs4hx7377rsb/X78+HG98847uvnmmzVx4sQWvjIAcE2MsQcAONy5c+d04sQJSdKTTz6p5557TpL0gx/8QB999FGTbZtaDactxwUAT0ewBwA4XHJysgzDUEBAgK699lr97Gc/049+9CNVV1fr9ttv1xdffHHFtk2Nr2/LcQHA0xHsAQAOVzdcZvDgwbJYLJKkF154QdOmTdO5c+d0yy23KDc395J2x48f1+HDh9WtWzeNHz/eYccFAG9AsAcAOFxdAB82bFj9cxaLRW+++abi4+OVkZGh2bNnq6ysrFG7ut76WbNm1Qd3RxwXALwBwR4A4HB1ATwhIaHR8507d9YHH3yg8PBw7du3T3fffbfsdnv99qbG17fluADgDQj2AACHKisr09GjRyU17lmvExMTo3Xr1ikgIEDvvPOOHn30UUlSXl6edu7cqYCAAE2dOtVhxwUAb8FylwAAh7LZbKqurm5yn9GjR18yXOb999+X3W7XlClTZLPZHHZcAPAW9NgDAFxC3TCcy92UCgBwdfTYAwBcwvjx45WQkHDF8fUAgKYR7AEALuGxxx5zdgkA4NZMhmEYzi4CAAAAQNswxh4AAADwAAR7AAAAwAMQ7AEAAAAPQLAHAAAAPADBHgAAAPAABHsAAADAAxDsAQAAAA9AsAcAAAA8AMEeAAAA8AAEewAAAMADEOwBAAAAD/D/A3Gqk3VHxxZzAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(k_values_normalised, power_spectrum)\n", + "plt.yscale(\"log\")\n", + "plt.xscale(\"log\")\n", + "plt.ylabel(r\"$\\mathcal{P}_{\\mathcal{R}}(k)$\")\n", + "plt.xlabel(r\"$k/k_{\\rm T}$\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/User guides/Advanced/Gaussian_bump/Gaussian bump potential 2 - noise modelling.ipynb b/User guides/Advanced/Gaussian_bump/Gaussian bump potential 2 - noise modelling.ipynb new file mode 100644 index 0000000..7b9498a --- /dev/null +++ b/User guides/Advanced/Gaussian_bump/Gaussian bump potential 2 - noise modelling.ipynb @@ -0,0 +1,1445 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gaussian bump potential 2 - noise modelling\n", + "\n", + "This is the second in a series of notebooks which will run importance sampling for the Gaussian bump potential. Familiarity with stochastic inflation and covariance matrices is assumed, see for example https://arxiv.org/pdf/2303.17375\n", + "\n", + "In this notebook we show how the different noise curves can be found using the background trajectory. We use the Bessel matching approach to find the homogeneous noise.\n", + "\n", + "Throughout natural units with $c = 8\\pi M_{\\rm PL} = \\hbar =1$ are used." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import mystyle\n", + "plt.style.use(mystyle.paper_style)\n", + "\n", + "from scipy.interpolate import CubicSpline\n", + "from scipy.integrate import odeint\n", + "from scipy.integrate import RK45\n", + "from scipy.optimize import root\n", + "from scipy.integrate import quad\n", + "from timeit import default_timer as timer\n", + "\n", + "from mpmath import besselj as besselj_func\n", + "from mpmath import bessely as bessely_func\n", + "from mpmath import gamma as gamma_func" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The potential\n", + "This is the [Gaussian bump potential](https://arxiv.org/abs/1911.00057)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def potential(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return V_0*fraction*(1 + K*expo)\n", + "\n", + "def potential_functional_form(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return fraction*(1 + K*expo)\n", + "\n", + "def potential_dif(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction1 = (phi**2)/(m_squared + phi**2)\n", + " fraction2 = (phi)/(m_squared + phi**2) - (phi**3)/((m_squared + phi**2)**2)\n", + " \n", + " term1 = 2*V_0*fraction2*(1 + K*expo)\n", + " term2 = V_0*fraction1*(-K*expo*(phi-phi_0)/(sigma_tilde**2))\n", + " return term1 + term2\n", + "\n", + "# I tested this against an interpolation of my previous derivative\n", + "def potential_ddif(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " square_brackets = 1 + K*expo\n", + " overall_factor = 2*V_0/(m_squared + phi**2)\n", + " \n", + " term1 = -2*potential_dif(phi)*phi/(m_squared + phi**2)\n", + " term2 = overall_factor*(1 - 3*(phi**2)/(m_squared + phi**2) + 2*(phi**4)/((m_squared + phi**2)**2))*\\\n", + " (1 + K*expo)\n", + " term3 = overall_factor*(phi - (phi**3)/(m_squared + phi**2))*(-K*(phi-phi_0)*expo/(sigma_tilde**2))\n", + " term4 = -overall_factor*0.5*phi*K*(3*phi - 2*phi_0)*expo/(sigma_tilde**2)\n", + " term5 = overall_factor*0.5*K*expo*(phi*(phi-phi_0)/(sigma_tilde**2))**2\n", + " \n", + " return term1 + term2 + term3 + term4 + term5\n", + "\n", + "def V_prime_by_V(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction3 = 1/phi - (phi)/(m_squared + phi**2)\n", + " fraction4 = -(phi-phi_0)/(sigma_tilde**2)\n", + " \n", + " term1 = 2*fraction3\n", + " term2 = fraction4*K*expo/(1 + K*expo)\n", + " return term1 + term2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are shown such that the power spectrum peaks at $5 \\times 10^{-3}$ in the astroid mass gap." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "K = 1.17*(10**-3) # This needs all 3 sig fig\n", + "cmb_power = 2*10**-9\n", + "cmb_phi = 3.0\n", + "phi_0 = 2.18812\n", + "m = 0.5\n", + "m_squared = m**2\n", + "sigma_tilde = 1.59*(10**-2)\n", + "\n", + "V_0 = 12*(np.pi**2)*(cmb_power/potential_functional_form(cmb_phi))*(V_prime_by_V(cmb_phi)**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading in background\n", + "We have already simulated the background, now we can just load it in." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "background_data = pd.read_csv(\"gaussian_bump_dynamics_dynamics\"+\".csv\", index_col=0)\n", + "\n", + "N_values = np.array(background_data[\"N\"])\n", + "phi_values = np.array(background_data[\"phi\"])\n", + "phi_diff_values = np.array(background_data[\"phi_N_diff\"])\n", + "hubble_param_values = np.array(background_data[\"H\"])\n", + "epsilon1_values = np.array(background_data[\"epsilon1\"])\n", + "epsilon2_values = np.array(background_data[\"epsilon2\"])\n", + "nu_squared_values = np.array(background_data[\"nu_squared\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's interpolate over this data." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "hubble_param_interpolation = CubicSpline(N_values, hubble_param_values)\n", + "epsilon1_interpolation = CubicSpline(N_values, epsilon1_values)\n", + "epsilon2_interpolation = CubicSpline(N_values, epsilon2_values)\n", + "nu_squared_interpolation = CubicSpline(N_values, nu_squared_values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are also a few constants we need." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "N_end = N_values[-1]\n", + "\n", + "N_usr_start = 29.84178346243688\n", + "N_end_start = 32.25059795813168\n", + "\n", + "a_in = 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Noise modelling\n", + "We find the noise using the values of $\\mathcal{R}$ we found in the previous note book. This is done by corase graining at some $\\sigma$ to find the noise at that time, then repeatig for all of the simulated modes. The noise curves are found by interpolating over these data points.\n", + "\n", + "We will first show how this is done with direct coarse graining, before detailing the method of Bessel matching" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below are many of the functions we will need" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def find_cg_time(k, sigma, N_exit):\n", + " def exit_time_func(N_cg_exit):\n", + " return k - sigma*aH_interpolation(N_cg_exit)\n", + " N_guess = N_exit + np.log(sigma**-1)\n", + " sol_cg_time = root(exit_time_func, N_guess)\n", + " N_cg_exit = sol_cg_time.x\n", + " return float(N_cg_exit)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def delta_phi_from_R(N_interest, R, R_N_derivative):\n", + " epsilon1 = epsilon1_interpolation(N_interest)\n", + " return R*(2*epsilon1)**0.5\n", + "\n", + "def delta_phi_N_derivative_from_R(N_interest, R, R_N_derivative):\n", + " epsilon1 = epsilon1_interpolation(N_interest)\n", + " epsilon2 = epsilon2_interpolation(N_interest)\n", + " return (0.5*epsilon2*R + R_N_derivative)*(2*epsilon1)**0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def correlation_matrix(delta_phi, delta_phi_derivative, k_sigma, epsilon1):\n", + " overall_amplitude = (1/(2*np.pi**2))*(1-epsilon1)*k_sigma**3\n", + "\n", + " phi_noise = overall_amplitude*np.abs(delta_phi)**2\n", + " pi_noise = overall_amplitude*np.abs(delta_phi_derivative)**2\n", + " # To make sure the complex conjugate can be calculated\n", + " delta_phi_normed = delta_phi/np.abs(delta_phi)\n", + " delta_phi_diff_conj_normed = np.conjugate(delta_phi_derivative)/np.abs(delta_phi)\n", + " correlation = overall_amplitude*(delta_phi_normed*delta_phi_diff_conj_normed)\n", + " # Need to then multiple by this overall amplitude\n", + " correlation = correlation*np.abs(delta_phi)**2\n", + " return np.array([phi_noise, correlation, np.conjugate(correlation), pi_noise])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's load in the results of our mode simulations" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "matching_data = pd.read_csv(\"gaussian_bump_range_of_R_values_at_different_sigma\"+\".csv\",\n", + " index_col=0)\n", + "\n", + "N_modes = np.array(matching_data[\"N exit\"])\n", + "k_raw_values = np.array(matching_data[\"k\"])\n", + "R_end_values = np.array(matching_data[\"R end\"], dtype=np.complex64)\n", + "\n", + "\n", + "R_at_sigma_values = np.zeros((len(sigma_values), len(N_modes)), dtype=\"complex\")\n", + "R_diff_at_sigma_values = np.zeros((len(sigma_values), len(N_modes)), dtype=\"complex\")\n", + "\n", + "for j in range(len(sigma_values)):\n", + " R_at_sigma_values[j, :] = matching_data[\"R at sigma \"+str(sigma_values[j])]\n", + " R_diff_at_sigma_values[j, :] = matching_data[\"R diff at sigma \"+str(sigma_values[j])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to define the start and end times. The values below correspond to the values chosen in the paper." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "N_sim_start = 31.13831633\n", + "N_sim_end = 39.1497714" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Direct coase graining\n", + "\n", + "Now let's find the covariance curves for direct coarse graining. We have already found the $\\mathcal{R}$ and $\\partial_N \\mathcal{R}$ values at the different coarse-graining times." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "sigma_index = 3\n", + "\n", + "sigma = sigma_values[sigma_index]\n", + "\n", + "# Create the coarse-grained N values array\n", + "logic = (N_modes>N_sim_start-1) & ((N_modes<=N_sim_end+1))\n", + "N_modes_interest = N_modes[logic]\n", + "\n", + "N_cg_values = np.zeros(len(N_modes_interest))\n", + "\n", + "# Also need to slice the R modes\n", + "R_values_interest = R_at_sigma_values[sigma_index, logic]\n", + "R_diff_values_interest = R_diff_at_sigma_values[sigma_index, logic]\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_sim_start))\n", + "\n", + "N_start_sigma_exit = find_cg_time(aH_interpolation(N_sim_start), sigma, N_sim_start)\n", + "N_end_sigma_exit = find_cg_time(aH_interpolation(N_sim_end), sigma, N_sim_end)\n", + "\n", + "k_in_scale = aH_interpolation(N_sim_start)\n", + "k_end_scale = aH_interpolation(N_sim_end)\n", + "\n", + "# As it is a symmetric matrix, only need to store 3 values\n", + "covaraince_matrix_array = np.zeros((3, len(N_modes_interest)))\n", + "\n", + "for i in range(len(N_modes_interest)):\n", + " N_mode_exit = N_modes_interest[i]\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " # Find when this mode left the coarse-graining scale\n", + " N_eval = find_cg_time(k, sigma, N_mode_exit)\n", + " N_cg_values[i] = N_eval\n", + "\n", + " R_at_sigma = R_values_interest[i]\n", + " R_diff_at_sigma = R_diff_values_interest[i]\n", + "\n", + " # Now we can find delta phi from these values\n", + " delta_phi_at_sigma = delta_phi_from_R(N_eval, R_at_sigma, R_diff_at_sigma)\n", + " delta_phi_deriv_at_sigma = delta_phi_N_derivative_from_R(N_eval, R_at_sigma, R_diff_at_sigma)\n", + "\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covaraince_matrix = np.array([[covar_matrix[0], covar_matrix[1]], [covar_matrix[2], covar_matrix[3]]])\n", + " covaraince_matrix = covaraince_matrix.real\n", + " covaraince_matrix_array[0, i] = covaraince_matrix[0, 0]\n", + " covaraince_matrix_array[1, i] = covaraince_matrix[0, 1]\n", + " covaraince_matrix_array[2, i] = covaraince_matrix[1, 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values, covaraince_matrix_array[0, :],\n", + " label=r\"$\\Xi_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, np.abs(covaraince_matrix_array[1, :]),\n", + " label=r\"$|\\Xi_{\\phi \\pi}|$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, covaraince_matrix_array[2, :],\n", + " label=r\"$\\Xi_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$\\Xi_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Gaussian bump, direct CG 2D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the extended range to allow interpolation. Let's show the range we will actually use.This will require fidning when the modes corresponding to the start and end left the coarse-graining scale (not the Hubble scale)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "N_sim_start_sigma_001 = find_cg_time(aH_interpolation(N_sim_start), sigma, N_sim_start)\n", + "N_sim_end_sigma_001 = find_cg_time(aH_interpolation(N_sim_end), sigma, N_sim_end)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values, covaraince_matrix_array[0, :],\n", + " label=r\"$\\Xi_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, np.abs(covaraince_matrix_array[1, :]),\n", + " label=r\"$|\\Xi_{\\phi \\pi}|$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, covaraince_matrix_array[2, :],\n", + " label=r\"$\\Xi_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.axvline(x=N_sim_start_sigma_001, color=\"k\", linestyle=\"dashed\", label=r\"Simulated range\")\n", + "plt.axvline(x=N_sim_end_sigma_001, color=\"k\", linestyle=\"dashed\")\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$\\Xi_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Gaussian bump, direct CG 2D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use an extended range to make sure the interpolation we do later is accurate. Let's plot the limited range" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "logic = (N_cg_values>=N_sim_start_sigma_001) & (N_cg_values<=N_sim_end_sigma_001)\n", + "\n", + "plt.plot(N_cg_values[logic], covaraince_matrix_array[0, :][logic],\n", + " label=r\"$\\Xi_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values[logic], np.abs(covaraince_matrix_array[1, :][logic]),\n", + " label=r\"$|\\Xi_{\\phi \\pi}|$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values[logic], covaraince_matrix_array[2, :][logic],\n", + " label=r\"$\\Xi_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$\\Xi_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Gaussian bump, direct CG 2D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If one is interesting in using this approach to find the noise, then you need to find the noise matrix, $S = \\Xi^2$, from the above. Let's do this using eigen decomposition" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# We need a constant to normalise the covariance to reasonable values, \n", + "# to make taking the squareroot more accurate\n", + "\n", + "diff_const = hubble_param_interpolation(N_usr_start)/(2*np.pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1150606/2636905509.py:56: RuntimeWarning: invalid value encountered in double_scalars\n", + " Lambda_root = np.asmatrix([[eigenvalues[0]**0.5, 0], [0, eigenvalues[1]**0.5]])\n" + ] + } + ], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "sigma_index = 3\n", + "\n", + "sigma = sigma_values[sigma_index]\n", + "\n", + "# Create the coarse-grained N values array\n", + "logic = (N_modes>N_sim_start-1) & ((N_modes<=N_sim_end+1))\n", + "N_modes_interest = N_modes[logic]\n", + "\n", + "N_cg_values = np.zeros(len(N_modes_interest))\n", + "\n", + "# Also need to slice the R modes\n", + "R_values_interest = R_at_sigma_values[sigma_index, logic]\n", + "R_diff_values_interest = R_diff_at_sigma_values[sigma_index, logic]\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_sim_start))\n", + "\n", + "N_start_sigma_exit = find_cg_time(aH_interpolation(N_sim_start), sigma, N_sim_start)\n", + "N_end_sigma_exit = find_cg_time(aH_interpolation(N_sim_end), sigma, N_sim_end)\n", + "\n", + "k_in_scale = aH_interpolation(N_sim_start)\n", + "k_end_scale = aH_interpolation(N_sim_end)\n", + "\n", + "# As it is a symmetric matrix, only need to store 3 values\n", + "noise_matrix_array = np.zeros((3, len(N_modes_interest)))\n", + "\n", + "for i in range(len(N_modes_interest)):\n", + " N_mode_exit = N_modes_interest[i]\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " # Find when this mode left the coarse-graining scale\n", + " N_eval = find_cg_time(k, sigma, N_mode_exit)\n", + " N_cg_values[i] = N_eval\n", + "\n", + " R_at_sigma = R_values_interest[i]\n", + " R_diff_at_sigma = R_diff_values_interest[i]\n", + "\n", + " # Now we can find delta phi from these values\n", + " delta_phi_at_sigma = delta_phi_from_R(N_eval, R_at_sigma, R_diff_at_sigma)\n", + " delta_phi_deriv_at_sigma = delta_phi_N_derivative_from_R(N_eval, R_at_sigma, R_diff_at_sigma)\n", + "\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covaraince_matrix = np.array([[covar_matrix[0], covar_matrix[1]], [covar_matrix[2], covar_matrix[3]]])\n", + " covaraince_matrix = covaraince_matrix/(diff_const**2)\n", + " covaraince_matrix = covaraince_matrix.real\n", + " eigenvalues, eigenvectors = np.linalg.eig(covaraince_matrix)\n", + " # Find the inverse eigenvector for diagonalisation\n", + " eigenvectors_inverse = np.linalg.inv(eigenvectors)\n", + " # Now find the square root of the eigen value matrix\n", + " Lambda_root = np.asmatrix([[eigenvalues[0]**0.5, 0], [0, eigenvalues[1]**0.5]])\n", + " noise_matrix = eigenvectors*Lambda_root*eigenvectors_inverse\n", + " noise_matrix_array[0, i] = noise_matrix[0, 0]\n", + " noise_matrix_array[1, i] = noise_matrix[0, 1]\n", + " noise_matrix_array[2, i] = noise_matrix[1, 1]\n", + "\n", + "# Rescale at the end\n", + "noise_matrix_array = noise_matrix_array*(diff_const)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that it is difficult to find the square root of an almost singular matrix, hence the NaN dta points." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values, noise_matrix_array[0, :],\n", + " label=r\"$S_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, np.abs(noise_matrix_array[1, :]),\n", + " label=r\"$|S_{\\phi \\pi}|$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, noise_matrix_array[2, :],\n", + " label=r\"$S_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.axvline(x=N_sim_start_sigma_001, color=\"k\", linestyle=\"dashed\", label=r\"Simulated range\")\n", + "plt.axvline(x=N_sim_end_sigma_001, color=\"k\", linestyle=\"dashed\")\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$S_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Gaussian bump, direct CG, 2D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These are clear gaps due to NaN! But the overall curve is clear. Let's remove the NaN data points and replot." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of nan noise data points\n", + "61\n" + ] + } + ], + "source": [ + "nan_logic = ~np.isnan(noise_matrix_array[0, :])\n", + "N_cg_values = N_cg_values[nan_logic]\n", + "if any(nan_logic==False):\n", + " print(\"Number of nan noise data points\")\n", + " print(len(N_modes_interest) - len(N_cg_values))\n", + "\n", + "noise_matrix_array = noise_matrix_array[:, nan_logic]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values, noise_matrix_array[0, :],\n", + " label=r\"$S_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, np.abs(noise_matrix_array[1, :]),\n", + " label=r\"$|S_{\\phi \\pi}|$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, noise_matrix_array[2, :],\n", + " label=r\"$S_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.axvline(x=N_sim_start_sigma_001, color=\"k\", linestyle=\"dashed\", label=r\"Simulated range\")\n", + "plt.axvline(x=N_sim_end_sigma_001, color=\"k\", linestyle=\"dashed\")\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$S_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Gaussian bump, direct CG, 2D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bessel matched approach\n", + "### 2D noise\n", + "Now let us use the approach to find the noise in the paper. This utilises a Bessel-function anzats, valid when the parameter $\\nu^2$ is close to a constant, to find the homogeneous component of $\\delta \\phi$. The functions required to do this are below." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def comoving_time_func(N_interest, N_end):\n", + " def comoving_time_integrand(N):\n", + " aH = aH_interpolation(N)\n", + " return 1/aH\n", + " comoving_time_value, _ = quad(comoving_time_integrand, N_end, N_interest, limit=1000)\n", + " return comoving_time_value\n", + "\n", + "def besselj_derivative_func(comoving_time, nu, k):\n", + " J_plus_1 = besselj_func(nu+1, -k*comoving_time)\n", + " J_minus_1 = besselj_func(nu-1, -k*comoving_time)\n", + " return (k/2)*(J_plus_1 - J_minus_1)\n", + "\n", + "def bessely_derivative_func(comoving_time, nu, k):\n", + " Y_plus_1 = bessely_func(nu+1, -k*comoving_time)\n", + " Y_minus_1 = bessely_func(nu-1, -k*comoving_time)\n", + " return (k/2)*(Y_plus_1 - Y_minus_1)\n", + "\n", + "def R_matching_to_Bessels(R, R_diff, N_interest, N_end, nu, k):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " epsilon1 = epsilon1_interpolation(N_interest)\n", + " epsilon2 = epsilon2_interpolation(N_interest)\n", + " a = a_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " z = (2*epsilon1*a**2)**0.5\n", + " z_prime_z = aH*(1 + 0.5*epsilon2)\n", + " extra_term = -(z_prime_z + 1/(-2*comoving_time))\n", + " besselj_value = besselj_func(nu, -k*comoving_time)\n", + " bessely_value = bessely_func(nu, -k*comoving_time)\n", + " besselj_diff_value = besselj_derivative_func(comoving_time, nu, k)\n", + " bessely_diff_value = bessely_derivative_func(comoving_time, nu, k)\n", + " # Need to convert to comoving time\n", + " R_prime = aH*R_diff\n", + " # Factor to change to R\n", + " prefactor = ((-comoving_time)**0.5)/z\n", + " # Now the different pre-factors needed to find A and B\n", + " c = prefactor*besselj_value\n", + " d = prefactor*bessely_value\n", + " e = prefactor*(extra_term*besselj_value + besselj_diff_value)\n", + " f = prefactor*(extra_term*bessely_value + bessely_diff_value)\n", + " # Now just need to solve standard system of simultanious equations\n", + " B = (c*R_prime - e*R)/(c*f - d*e)\n", + " A = (R - B*d)/c\n", + " return complex(A), complex(B)\n", + "\n", + "def homogeneous_Bessel_delta_phi(N_interest, N_end, nu, k, A, B, just_growing=False):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_comoving_time = -k*comoving_time\n", + " a = a_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " term1 = (A/gamma_func(nu+1) - B*gamma_func(-nu)*np.cos(nu*np.pi)/np.pi)*(0.5*k_comoving_time)**nu\n", + " term2 = (-B*gamma_func(nu)/np.pi)*(0.5*k_comoving_time)**-nu\n", + " if just_growing==True:\n", + " sasaki_mukanov = (term2)*(-comoving_time)**0.5\n", + " else:\n", + " sasaki_mukanov = (term1 + term2)*(-comoving_time)**0.5\n", + " delta_phi = sasaki_mukanov/a\n", + " return complex(delta_phi)\n", + "\n", + "def homogeneous_Bessel_delta_phi_N_derivative(N_interest, N_end, nu, k, A, B, just_growing=False):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_comoving_time = -k*comoving_time\n", + " a = a_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " extra_term = (-aH + 0.5/comoving_time)\n", + " d = (-B*gamma_func(nu)/np.pi)\n", + " if just_growing==True:\n", + " # this is the coefficent of the decaying mde, so if we set it to zero we are neglecting it\n", + " c = 0.\n", + " else:\n", + " c = (A/gamma_func(nu+1) - B*gamma_func(-nu)*np.cos(nu*np.pi)/np.pi)\n", + " # This includes the 1/aH from changing to an N derivative, dN = aH d comoving time\n", + " prefactor = ((-comoving_time)**0.5)/(aH*a)\n", + " term_1 = extra_term*(c*(0.5*k_comoving_time)**(nu) + d*(0.5*k_comoving_time)**(-nu))\n", + " term_2 = 0.5*(nu*k)*(-c*(0.5*k_comoving_time)**(nu-1) + d*(0.5*k_comoving_time)**(-nu - 1))\n", + " delta_phi_homo_derivative = prefactor*(term_1 + term_2)\n", + " return complex(delta_phi_homo_derivative)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's find the noise matrix for $\\sigma=0.01$ for the case of homogeneous matching." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step is\n", + "0.00023659513392999544\n" + ] + } + ], + "source": [ + "# Also need to define the dN used for the numerical steps later. We use a smaller value of the smallest RK45 step\n", + "dN = 0.1*np.min(np.diff(N_values))\n", + "print(\"step is\")\n", + "print(dN)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1150606/3940784777.py:64: RuntimeWarning: invalid value encountered in double_scalars\n", + " Lambda_root = np.asmatrix([[eigenvalues[0]**0.5, 0], [0, eigenvalues[1]**0.5]])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of nan noise data points\n", + "41\n", + "Diff in start value\n", + "0.0\n", + "Diff in final value\n", + "-1.8588466410562887e-05\n" + ] + } + ], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "sigma_index = 3\n", + "\n", + "sigma = sigma_values[sigma_index]\n", + "\n", + "# Create the coarse-grained N values array\n", + "logic = (N_modes>N_sim_start-1) & ((N_modes<=N_sim_end+1))\n", + "N_modes_interest = N_modes[logic]\n", + "\n", + "N_cg_values = np.zeros(len(N_modes_interest))\n", + "\n", + "# Also need to slice the R modes\n", + "R_values_interest = R_at_sigma_values[sigma_index, logic]\n", + "R_diff_values_interest = R_diff_at_sigma_values[sigma_index, logic]\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_sim_start))\n", + "\n", + "N_start_sigma_exit = find_cg_time(aH_interpolation(N_sim_start), sigma, N_sim_start)\n", + "N_end_sigma_exit = find_cg_time(aH_interpolation(N_sim_end), sigma, N_sim_end)\n", + "\n", + "k_in_scale = aH_interpolation(N_sim_start)\n", + "k_end_scale = aH_interpolation(N_sim_end)\n", + "\n", + "noise_matrix_array_for_interpolation = np.zeros((3, len(N_modes_interest)))\n", + "for i in range(len(N_modes_interest)):\n", + " N_mode_exit = N_modes_interest[i]\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " # Find when this mode left the coarse-graining scale\n", + " N_eval = find_cg_time(k, sigma, N_mode_exit)\n", + " N_cg_values[i] = N_eval\n", + "\n", + " R_at_sigma = R_values_interest[i]\n", + " R_diff_at_sigma = R_diff_values_interest[i]\n", + "\n", + " nu_squared = nu_squared_interpolation(N_eval)\n", + " if nu_squared<0:\n", + " nu = complex(nu_squared_interpolation(N_eval), 0)**0.5\n", + " else:\n", + " nu = nu_squared**0.5\n", + "\n", + " A, B = R_matching_to_Bessels(R_at_sigma, R_diff_at_sigma, N_eval, N_end, nu, k)\n", + " # Now we can find delta phi from these values\n", + " delta_phi_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi(N_eval, N_end, nu, k, A, B)\n", + " delta_phi_deriv_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi_N_derivative(N_eval, N_end, nu, k, A, B)\n", + "\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covaraince_matrix = np.array([[covar_matrix[0], covar_matrix[1]], [covar_matrix[2], covar_matrix[3]]])\n", + " # Normalise to hopefully mke the square root more accurate\n", + " covaraince_matrix = covaraince_matrix/(diff_const**2)\n", + " covaraince_matrix = covaraince_matrix.real\n", + " eigenvalues, eigenvectors = np.linalg.eig(covaraince_matrix)\n", + " # Find the inverse eigenvector for diagonalisation\n", + " eigenvectors_inverse = np.linalg.inv(eigenvectors)\n", + " # Now find the square root of the eigen value matrix\n", + " Lambda_root = np.asmatrix([[eigenvalues[0]**0.5, 0], [0, eigenvalues[1]**0.5]])\n", + " noise_matrix = eigenvectors*Lambda_root*eigenvectors_inverse\n", + " # As this is symmetric, let's convert it back into its usual form\n", + " noise_matrix_array_for_interpolation[0, i] = noise_matrix[0, 0]\n", + " noise_matrix_array_for_interpolation[1, i] = noise_matrix[0, 1]\n", + " noise_matrix_array_for_interpolation[2, i] = noise_matrix[1, 1]\n", + "\n", + "nan_logic = ~np.isnan(noise_matrix_array_for_interpolation[0, :])\n", + "N_cg_values = N_cg_values[nan_logic]\n", + "if any(nan_logic==False):\n", + " print(\"Number of nan noise data points\")\n", + " print(len(N_modes_interest) - len(N_cg_values))\n", + "\n", + "# Remove the NaN points\n", + "noise_matrix_array_for_interpolation = noise_matrix_array_for_interpolation[:, nan_logic]\n", + "\n", + "# Need to rescale back to the correct magnitude\n", + "noise_matrix_array_for_interpolation = diff_const*noise_matrix_array_for_interpolation\n", + "\n", + "# Do an interpolation such that the noise at any time of interest can be found\n", + "noise_matrix_phi_phi_interpolation = CubicSpline(N_cg_values,\n", + " noise_matrix_array_for_interpolation[0, :])\n", + "noise_matrix_phi_pi_interpolation = CubicSpline(N_cg_values,\n", + " noise_matrix_array_for_interpolation[1, :])\n", + "noise_matrix_pi_pi_interpolation = CubicSpline(N_cg_values,\n", + " noise_matrix_array_for_interpolation[2, :])\n", + "\n", + "#N_cg_values_for_sim = np.arange(N_start_sigma_exit, N_end_sigma_exit, dN)\n", + "N_cg_values_for_sim = np.arange(N_start_sigma_exit, N_end_sigma_exit, dN)\n", + "print(\"Diff in start value\")\n", + "print(N_cg_values_for_sim[0] - N_start_sigma_exit)\n", + "print(\"Diff in final value\")\n", + "print(N_cg_values_for_sim[-1] - N_end_sigma_exit)\n", + "noise_matrix_array = np.zeros((3, len(N_cg_values_for_sim)))\n", + "\n", + "# Let's find the noise at each time step used\n", + "noise_matrix_array[0, :len(N_cg_values_for_sim)] =\\\n", + " noise_matrix_phi_phi_interpolation(N_cg_values_for_sim)\n", + "noise_matrix_array[1, :len(N_cg_values_for_sim)] =\\\n", + " noise_matrix_phi_pi_interpolation(N_cg_values_for_sim)\n", + "noise_matrix_array[2, :len(N_cg_values_for_sim)] =\\\n", + " noise_matrix_pi_pi_interpolation(N_cg_values_for_sim)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values_for_sim, noise_matrix_array[0, :],\n", + " label=r\"$S_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values_for_sim, np.abs(noise_matrix_array[1, :]),\n", + " label=r\"$|S_{\\phi \\pi}|$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values_for_sim, noise_matrix_array[2, :],\n", + " label=r\"$S_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.axvline(x=N_sim_start_sigma_001, color=\"k\", linestyle=\"dashed\", label=r\"Simulated range\")\n", + "plt.axvline(x=N_sim_end_sigma_001, color=\"k\", linestyle=\"dashed\")\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$S_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Gaussian bump, $\\delta \\phi_{\\rm h}$, 2D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This looks very similair to the direct coarse grainiing plot, which is to be expected for $\\sigma=0.01$ as the $k^2$ correction is minimal." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's save these noise curves for later use." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "data_dict = {}\n", + "data_dict[\"N\"] = N_cg_values_for_sim\n", + "data_dict[\"phi-phi noise\"] = noise_matrix_array[0, :]\n", + "data_dict[\"phi-pi noise\"] = noise_matrix_array[1, :]\n", + "data_dict[\"pi-pi noise\"] = noise_matrix_array[2, :]\n", + "\n", + "data_pandas = pd.DataFrame(data_dict)\n", + "\n", + "data_pandas.to_csv(\"gaussian_bump_noise_curves_Bessel_matched_sigma_\"+str(sigma)+\"_2D.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1D noise\n", + "We can also find a 1D noise if the decaying mode is dropped. Let's find this for $\\sigma=0.01$ initially.\n", + "\n", + "The covariance matrix for 1D noise does not have a squareroot. So instead we just find the noise from the first element and the angle made by the noise in phase space" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "sigma_index = 3\n", + "\n", + "sigma = sigma_values[sigma_index]\n", + "\n", + "# Create the coarse-grained N values array\n", + "logic = (N_modes>N_sim_start-1) & ((N_modes<=N_sim_end+1))\n", + "N_modes_interest = N_modes[logic]\n", + "\n", + "N_cg_values = np.zeros(len(N_modes_interest))\n", + "\n", + "# Also need to slice the R modes\n", + "R_values_interest = R_at_sigma_values[sigma_index, logic]\n", + "R_diff_values_interest = R_diff_at_sigma_values[sigma_index, logic]\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_sim_start))\n", + "\n", + "N_start_sigma_exit = find_cg_time(aH_interpolation(N_sim_start), sigma, N_sim_start)\n", + "N_end_sigma_exit = find_cg_time(aH_interpolation(N_sim_end), sigma, N_sim_end)\n", + "\n", + "k_in_scale = aH_interpolation(N_sim_start)\n", + "k_end_scale = aH_interpolation(N_sim_end)\n", + "\n", + "noise_matrix_array_for_interpolation = np.zeros((3, len(N_modes_interest)))\n", + "for i in range(len(N_modes_interest)):\n", + " N_mode_exit = N_modes_interest[i]\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " # Find when this mode left the coarse-graining scale\n", + " N_eval = find_cg_time(k, sigma, N_mode_exit)\n", + " N_cg_values[i] = N_eval\n", + " nu = complex(nu_squared_interpolation(N_eval), 0)**0.5\n", + "\n", + " # We use these values to find the homogeneous behaviour\n", + " R_at_sigma = R_values_interest[i]\n", + " R_diff_at_sigma = R_diff_values_interest[i]\n", + " A, B = R_matching_to_Bessels(R_at_sigma, R_diff_at_sigma, N_eval, N_end, nu, k)\n", + " # Now we can find delta phi from these values\n", + " delta_phi_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " delta_phi_deriv_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi_N_derivative(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " tan_theta = np.real(delta_phi_deriv_at_sigma/delta_phi_at_sigma)\n", + "\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covar_matrix = covar_matrix.real\n", + " # The phi noise is just the element square root, then pi noise is just this times the ratio\n", + " noise_matrix_array_for_interpolation[0, i] = covar_matrix[0]**0.5\n", + " noise_matrix_array_for_interpolation[1, i] = tan_theta*covar_matrix[0]**0.5\n", + "\n", + "# Do an interpolation such that the noise at any time of interest can be found\n", + "noise_matrix_phi_phi_interpolation = CubicSpline(N_cg_values,\n", + " noise_matrix_array_for_interpolation[0, :])\n", + "noise_matrix_pi_pi_interpolation = CubicSpline(N_cg_values,\n", + " noise_matrix_array_for_interpolation[1, :])\n", + "\n", + "N_cg_values_for_sim = np.arange(N_start_sigma_exit, N_end_sigma_exit, dN)\n", + "noise_matrix_array = np.zeros((2, len(N_cg_values_for_sim)))\n", + "# Let's find the noise at each time step used\n", + "noise_matrix_array[0, :len(N_cg_values_for_sim)] = noise_matrix_phi_phi_interpolation(N_cg_values_for_sim)\n", + "noise_matrix_array[1, :len(N_cg_values_for_sim)] = noise_matrix_pi_pi_interpolation(N_cg_values_for_sim)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values_for_sim, noise_matrix_array[0, :],\n", + " label=r\"$S_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values_for_sim, noise_matrix_array[1, :],\n", + " label=r\"$S_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.axvline(x=N_sim_start_sigma_001, color=\"k\", linestyle=\"dashed\", label=r\"Simulated range\")\n", + "plt.axvline(x=N_sim_end_sigma_001, color=\"k\", linestyle=\"dashed\")\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$S_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Gaussian bump, $\\delta \\phi_{\\rm h}$, 1D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can see this looks very similair to the previous noise plots, as expected." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also find the noise near Hubble exit." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "sigma_index = 0\n", + "\n", + "sigma = sigma_values[sigma_index]\n", + "\n", + "# Create the coarse-grained N values array\n", + "logic = (N_modes>N_sim_start-1) & ((N_modes<=N_sim_end+1))\n", + "N_modes_interest = N_modes[logic]\n", + "\n", + "N_cg_values = np.zeros(len(N_modes_interest))\n", + "\n", + "# Also need to slice the R modes\n", + "R_values_interest = R_at_sigma_values[sigma_index, logic]\n", + "R_diff_values_interest = R_diff_at_sigma_values[sigma_index, logic]\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_sim_start))\n", + "\n", + "N_start_sigma_exit = find_cg_time(aH_interpolation(N_sim_start), sigma, N_sim_start)\n", + "N_end_sigma_exit = find_cg_time(aH_interpolation(N_sim_end), sigma, N_sim_end)\n", + "\n", + "k_in_scale = aH_interpolation(N_sim_start)\n", + "k_end_scale = aH_interpolation(N_sim_end)\n", + "\n", + "noise_matrix_array_for_interpolation = np.zeros((3, len(N_modes_interest)))\n", + "for i in range(len(N_modes_interest)):\n", + " N_mode_exit = N_modes_interest[i]\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " # Find when this mode left the coarse-graining scale\n", + " N_eval = find_cg_time(k, sigma, N_mode_exit)\n", + " N_cg_values[i] = N_eval\n", + " nu = complex(nu_squared_interpolation(N_eval), 0)**0.5\n", + "\n", + " # We use these values to find the homogeneous behaviour\n", + " R_at_sigma = R_values_interest[i]\n", + " R_diff_at_sigma = R_diff_values_interest[i]\n", + " A, B = R_matching_to_Bessels(R_at_sigma, R_diff_at_sigma, N_eval, N_end, nu, k)\n", + " # Now we can find delta phi from these values\n", + " delta_phi_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " delta_phi_deriv_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi_N_derivative(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " tan_theta = np.real(delta_phi_deriv_at_sigma/delta_phi_at_sigma)\n", + "\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covar_matrix = covar_matrix.real\n", + " # The phi noise is just the element square root, then pi noise is just this times the ratio\n", + " noise_matrix_array_for_interpolation[0, i] = covar_matrix[0]**0.5\n", + " noise_matrix_array_for_interpolation[1, i] = tan_theta*covar_matrix[0]**0.5\n", + "\n", + "# Do an interpolation such that the noise at any time of interest can be found\n", + "noise_matrix_phi_phi_interpolation = CubicSpline(N_cg_values,\n", + " noise_matrix_array_for_interpolation[0, :])\n", + "noise_matrix_pi_pi_interpolation = CubicSpline(N_cg_values,\n", + " noise_matrix_array_for_interpolation[1, :])\n", + "\n", + "N_cg_values_for_sim = np.arange(N_start_sigma_exit, N_end_sigma_exit, dN)\n", + "noise_matrix_array = np.zeros((2, len(N_cg_values_for_sim)))\n", + "# Let's find the noise at each time step used\n", + "noise_matrix_array[0, :len(N_cg_values_for_sim)] = noise_matrix_phi_phi_interpolation(N_cg_values_for_sim)\n", + "noise_matrix_array[1, :len(N_cg_values_for_sim)] = noise_matrix_pi_pi_interpolation(N_cg_values_for_sim)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values_for_sim, noise_matrix_array[0, :],\n", + " label=r\"$S_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values_for_sim, noise_matrix_array[1, :],\n", + " label=r\"$S_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.axvline(x=N_sim_start, color=\"k\", linestyle=\"dashed\", label=r\"Simulated range\")\n", + "plt.axvline(x=N_sim_end, color=\"k\", linestyle=\"dashed\")\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$S_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Gaussian bump, $\\delta \\phi_{\\rm h}$, 1D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can do the same for all of the different $\\sigma$ values, and save the different noise curves as we go.\n", + "\n", + "Note that we need to make sure to change the $\\mathcal{R}$ and $\\partial_N \\mathcal{R}$ values we use with $\\sigma$" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "# Create the coarse-grained N values array\n", + "logic = (N_modes>N_sim_start-1) & ((N_modes<=N_sim_end+1))\n", + "N_modes_interest = N_modes[logic]\n", + "\n", + "for sigma_index in range(len(sigma_values)):\n", + " sigma = sigma_values[sigma_index]\n", + " # Also need to slice the R modes\n", + " R_values_interest = R_at_sigma_values[sigma_index, logic]\n", + " R_diff_values_interest = R_diff_at_sigma_values[sigma_index, logic]\n", + "\n", + " # Renormalise\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_sim_start))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_sim_start))\n", + "\n", + " N_start_sigma_exit = find_cg_time(aH_interpolation(N_sim_start), sigma, N_sim_start)\n", + " N_end_sigma_exit = find_cg_time(aH_interpolation(N_sim_end), sigma, N_sim_end)\n", + "\n", + " N_cg_values = np.zeros(len(N_modes_interest))\n", + "\n", + " noise_matrix_array_for_interpolation = np.zeros((3, len(N_modes_interest)))\n", + " for i in range(len(N_modes_interest)):\n", + " N_mode_exit = N_modes_interest[i]\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " # Find when this mode left the coarse-graining scale\n", + " N_eval = find_cg_time(k, sigma, N_mode_exit)\n", + " N_cg_values[i] = N_eval\n", + " nu = complex(nu_squared_interpolation(N_eval), 0)**0.5\n", + "\n", + " # We use these values to find the homogeneous behaviour\n", + " R_at_sigma = R_values_interest[i]\n", + " R_diff_at_sigma = R_diff_values_interest[i]\n", + " A, B = R_matching_to_Bessels(R_at_sigma, R_diff_at_sigma, N_eval, N_end, nu, k)\n", + " # Now we can find delta phi from these values\n", + " delta_phi_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " delta_phi_deriv_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi_N_derivative(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " tan_theta = np.real(delta_phi_deriv_at_sigma/delta_phi_at_sigma)\n", + "\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covar_matrix = covar_matrix.real\n", + " # The phi noise is just the element square root, then pi noise is just this times the ratio\n", + " noise_matrix_array_for_interpolation[0, i] = covar_matrix[0]**0.5\n", + " noise_matrix_array_for_interpolation[1, i] = tan_theta*covar_matrix[0]**0.5\n", + "\n", + " # Do an interpolation such that the noise at any time of interest can be found\n", + " noise_matrix_phi_phi_interpolation = CubicSpline(N_cg_values,\n", + " noise_matrix_array_for_interpolation[0, :])\n", + " noise_matrix_pi_pi_interpolation = CubicSpline(N_cg_values,\n", + " noise_matrix_array_for_interpolation[1, :])\n", + "\n", + " N_cg_values_for_sim = np.arange(N_start_sigma_exit, N_end_sigma_exit, dN)\n", + " noise_matrix_array = np.zeros((2, len(N_cg_values_for_sim)))\n", + " # Let's find the noise at each time step used\n", + " noise_matrix_array[0, :len(N_cg_values_for_sim)] = noise_matrix_phi_phi_interpolation(N_cg_values_for_sim)\n", + " noise_matrix_array[1, :len(N_cg_values_for_sim)] = noise_matrix_pi_pi_interpolation(N_cg_values_for_sim)\n", + " \n", + " # Save these curves\n", + " data_dict = {}\n", + " data_dict[\"N\"] = N_cg_values_for_sim\n", + " data_dict[\"phi-phi noise\"] = noise_matrix_array[0, :]\n", + " data_dict[\"pi-pi noise\"] = noise_matrix_array[1, :]\n", + "\n", + " data_pandas = pd.DataFrame(data_dict)\n", + "\n", + " data_pandas.to_csv(\"gaussian_bump_noise_curves_Bessel_matched_sigma_\"+str(sigma)+\"_1D.csv\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/User guides/Advanced/Gaussian_bump/Gaussian bump potential 4 - importance sampling.ipynb b/User guides/Advanced/Gaussian_bump/Gaussian bump potential 4 - importance sampling.ipynb new file mode 100644 index 0000000..f806561 --- /dev/null +++ b/User guides/Advanced/Gaussian_bump/Gaussian bump potential 4 - importance sampling.ipynb @@ -0,0 +1,2295 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gaussian bump potential 4 - importance sampling\n", + "\n", + "This is the fourth, and final, in a series of notebooks which will run importance sampling for the Gaussian bump potential. Familiarity with importance sampling is assumed\n", + "\n", + "In this notebook we show how to run stochastic simulations and compare the different noise models.\n", + "\n", + "We start as we did before by defining everything we need and loading in the required data\n", + "\n", + "Throughout natural units with $c = 8\\pi M_{\\rm PL} = \\hbar =1$ are used." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import mystyle\n", + "plt.style.use(mystyle.paper_style)\n", + "\n", + "# Need to make sure you have pyfpt installed\n", + "import pyfpt as fpt\n", + "import multiprocessing as mp\n", + "from multiprocessing import Process, Queue\n", + "from timeit import default_timer as timer\n", + "\n", + "from scipy.optimize import root\n", + "from scipy.integrate import trapezoid\n", + "from scipy.interpolate import CubicSpline\n", + "\n", + "# Let us define the different colours used\n", + "color = ['#377eb8', '#ff7f00', '#984ea3','#4daf4a', '#a65628', '#f781bf','#999999', '#e41a1c', '#dede00']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The potential\n", + "This is the [Gaussian bump potential](https://arxiv.org/abs/1911.00057)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def potential(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return V_0*fraction*(1 + K*expo)\n", + "\n", + "def potential_functional_form(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return fraction*(1 + K*expo)\n", + "\n", + "def potential_dif(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction1 = (phi**2)/(m_squared + phi**2)\n", + " fraction2 = (phi)/(m_squared + phi**2) - (phi**3)/((m_squared + phi**2)**2)\n", + " \n", + " term1 = 2*V_0*fraction2*(1 + K*expo)\n", + " term2 = V_0*fraction1*(-K*expo*(phi-phi_0)/(sigma_tilde**2))\n", + " return term1 + term2\n", + "\n", + "# I tested this against an interpolation of my previous derivative\n", + "def potential_ddif(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " square_brackets = 1 + K*expo\n", + " overall_factor = 2*V_0/(m_squared + phi**2)\n", + " \n", + " term1 = -2*potential_dif(phi)*phi/(m_squared + phi**2)\n", + " term2 = overall_factor*(1 - 3*(phi**2)/(m_squared + phi**2) + 2*(phi**4)/((m_squared + phi**2)**2))*\\\n", + " (1 + K*expo)\n", + " term3 = overall_factor*(phi - (phi**3)/(m_squared + phi**2))*(-K*(phi-phi_0)*expo/(sigma_tilde**2))\n", + " term4 = -overall_factor*0.5*phi*K*(3*phi - 2*phi_0)*expo/(sigma_tilde**2)\n", + " term5 = overall_factor*0.5*K*expo*(phi*(phi-phi_0)/(sigma_tilde**2))**2\n", + " \n", + " return term1 + term2 + term3 + term4 + term5\n", + "\n", + "def V_prime_by_V(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction3 = 1/phi - (phi)/(m_squared + phi**2)\n", + " fraction4 = -(phi-phi_0)/(sigma_tilde**2)\n", + " \n", + " term1 = 2*fraction3\n", + " term2 = fraction4*K*expo/(1 + K*expo)\n", + " return term1 + term2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are shown such that the power spectrum peaks at $5 \\times 10^{-3}$ in the astroid mass gap." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "K = 1.17*(10**-3) # This needs all 3 sig fig\n", + "cmb_power = 2*10**-9\n", + "cmb_phi = 3.0\n", + "phi_0 = 2.18812\n", + "m = 0.5\n", + "m_squared = m**2\n", + "sigma_tilde = 1.59*(10**-2)\n", + "\n", + "V_0 = 12*(np.pi**2)*(cmb_power/potential_functional_form(cmb_phi))*(V_prime_by_V(cmb_phi)**2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading in background\n", + "We have already simulated the background, now we can just load it in." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "background_data = pd.read_csv(\"gaussian_bump_dynamics_dynamics\"+\".csv\", index_col=0)\n", + "\n", + "N_values = np.array(background_data[\"N\"])\n", + "phi_values = np.array(background_data[\"phi\"])\n", + "phi_diff_values = np.array(background_data[\"phi_N_diff\"])\n", + "hubble_param_values = np.array(background_data[\"H\"])\n", + "epsilon1_values = np.array(background_data[\"epsilon1\"])\n", + "epsilon2_values = np.array(background_data[\"epsilon2\"])\n", + "nu_squared_values = np.array(background_data[\"nu_squared\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's interpolate over this data." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "hubble_param_interpolation = CubicSpline(N_values, hubble_param_values)\n", + "epsilon1_interpolation = CubicSpline(N_values, epsilon1_values)\n", + "epsilon2_interpolation = CubicSpline(N_values, epsilon2_values)\n", + "nu_squared_interpolation = CubicSpline(N_values, nu_squared_values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are also a few constants and functions we need." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "N_end = N_values[-1]\n", + "\n", + "N_usr_start = 29.84178346243688\n", + "N_end_start = 32.25059795813168\n", + "\n", + "N_sim_start = 31.13831633\n", + "N_sim_end = 39.1497714\n", + "\n", + "a_in = 1.\n", + "\n", + "dN = 0.00023659513392999544\n", + "\n", + "analytical_fpt_std = 0.10104472578966923\n", + "\n", + "N_sim_end_later = N_sim_end+2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def find_cg_time(k, sigma, N_exit):\n", + " def exit_time_func(N_cg_exit):\n", + " return k - sigma*aH_interpolation(N_cg_exit)\n", + " N_guess = N_exit + np.log(sigma**-1)\n", + " sol_cg_time = root(exit_time_func, N_guess)\n", + " N_cg_exit = sol_cg_time.x\n", + " return float(N_cg_exit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Importance sampling\n", + "\n", + "Here we run simulations using importance sampling to investigate the far tail. As it is more straightforward to implement the 1D noise, that is what we do here. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext cython" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " Cython: _cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.pyx\n", + " \n", + "\n", + "\n", + "

Generated by Cython 3.0.7

\n", + "

\n", + " Yellow lines hint at Python interaction.
\n", + " Click on a line that starts with a \"+\" to see the C code that Cython generated for it.\n", + "

\n", + "
 001:
\n", + "
+002: import numpy as np
\n", + "
  __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 003:
\n", + "
+004: cdef double V_0 = 7.903587107979402e-11
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V_0 = 7.903587107979402e-11;\n",
+       "
+005: cdef double e = 2.718281828459045
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_e = 2.718281828459045;\n",
+       "
+006: cdef double pi_num = 3.141592653589793
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_pi_num = 3.141592653589793;\n",
+       "
+007: cdef double sigma_tilde = 1.59*(10**-2)
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde = (1.59 * pow(10.0, -2.0));\n",
+       "
+008: cdef double phi_0 = 2.18812
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_phi_0 = 2.18812;\n",
+       "
+009: cdef double m_squared = 0.25
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_m_squared = 0.25;\n",
+       "
+010: cdef double K = 1.17*(10**-3)
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_K = (1.17 * pow(10.0, -3.0));\n",
+       "
+011: cdef double diff_const_squared = 6.351213422073874e-13
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_diff_const_squared = 6.351213422073874e-13;\n",
+       "
 012: cdef double phi_end
\n", + "
 013: cdef double expo
\n", + "
 014: cdef double fraction
\n", + "
 015: cdef double fraction3
\n", + "
 016: cdef double fraction4
\n", + "
 017: cdef double noise_value
\n", + "
 018: cdef double bias_value
\n", + "
 019: cdef double term1
\n", + "
 020: cdef double term2
\n", + "
 021: cdef double phi_old
\n", + "
 022:
\n", + "
 023:
\n", + "
+024: cdef double V(double phi):
\n", + "
static double __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V(double __pyx_v_phi) {\n",
+       "  __pyx_t_double_complex __pyx_v_expo;\n",
+       "  double __pyx_v_fraction;\n",
+       "  double __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.V\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = -1;\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+025:     expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)
\n", + "
  __pyx_t_1 = (__pyx_v_phi - __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_phi_0);\n",
+       "  if (unlikely(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 25, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_expo = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_e, 0), __pyx_t_double_complex_from_parts((-0.5 * pow((__pyx_t_1 / __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde), 2.0)), 0));\n",
+       "
+026:     fraction = (phi**2)/(m_squared + phi**2)
\n", + "
  __pyx_t_1 = pow(__pyx_v_phi, 2.0);\n",
+       "  __pyx_t_2 = (__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_m_squared + pow(__pyx_v_phi, 2.0));\n",
+       "  if (unlikely(__pyx_t_2 == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 26, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_fraction = (__pyx_t_1 / __pyx_t_2);\n",
+       "
+027:     return V_0*fraction*(1 + K*expo)
\n", + "
  __pyx_t_2 = __Pyx_SoftComplexToDouble(__Pyx_c_prod_double(__pyx_t_double_complex_from_parts((__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V_0 * __pyx_v_fraction), 0), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(1, 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_K, 0), __pyx_v_expo))), 1); if (unlikely(__pyx_t_2 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 27, __pyx_L1_error)\n",
+       "  __pyx_r = __pyx_t_2;\n",
+       "  goto __pyx_L0;\n",
+       "
 028:
\n", + "
+029: cdef double V_prime_by_V_cython(double phi):
\n", + "
static double __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V_prime_by_V_cython(double __pyx_v_phi) {\n",
+       "  __pyx_t_double_complex __pyx_v_expo;\n",
+       "  double __pyx_v_fraction3;\n",
+       "  double __pyx_v_fraction4;\n",
+       "  double __pyx_v_term1;\n",
+       "  __pyx_t_double_complex __pyx_v_term2;\n",
+       "  double __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.V_prime_by_V_cython\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = -1;\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+030:     expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)
\n", + "
  __pyx_t_1 = (__pyx_v_phi - __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_phi_0);\n",
+       "  if (unlikely(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 30, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_expo = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_e, 0), __pyx_t_double_complex_from_parts((-0.5 * pow((__pyx_t_1 / __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde), 2.0)), 0));\n",
+       "
+031:     fraction3 = 1/phi - (phi)/(m_squared + phi**2)
\n", + "
  if (unlikely(__pyx_v_phi == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 31, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_1 = (__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_m_squared + pow(__pyx_v_phi, 2.0));\n",
+       "  if (unlikely(__pyx_t_1 == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 31, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_fraction3 = ((1.0 / __pyx_v_phi) - (__pyx_v_phi / __pyx_t_1));\n",
+       "
+032:     fraction4 = -(phi-phi_0)/(sigma_tilde**2)
\n", + "
  __pyx_t_1 = (-(__pyx_v_phi - __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_phi_0));\n",
+       "  __pyx_t_2 = pow(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde, 2.0);\n",
+       "  if (unlikely(__pyx_t_2 == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 32, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_fraction4 = (__pyx_t_1 / __pyx_t_2);\n",
+       "
 033:
\n", + "
+034:     term1 = 2*fraction3
\n", + "
  __pyx_v_term1 = (2.0 * __pyx_v_fraction3);\n",
+       "
+035:     term2 = fraction4*K*expo/(1 + K*expo)
\n", + "
  __pyx_t_3 = __Pyx_c_prod_double(__pyx_t_double_complex_from_parts((__pyx_v_fraction4 * __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_K), 0), __pyx_v_expo);\n",
+       "  __pyx_t_4 = __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(1, 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_K, 0), __pyx_v_expo));\n",
+       "  if (unlikely(__Pyx_c_is_zero_double(__pyx_t_4))) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 35, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_term2 = __Pyx_c_quot_double(__pyx_t_3, __pyx_t_4);\n",
+       "
+036:     return term1 + term2
\n", + "
  __pyx_t_2 = __Pyx_SoftComplexToDouble(__Pyx_c_sum_double(__pyx_t_double_complex_from_parts(__pyx_v_term1, 0), __pyx_v_term2), 1); if (unlikely(__pyx_t_2 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L1_error)\n",
+       "  __pyx_r = __pyx_t_2;\n",
+       "  goto __pyx_L0;\n",
+       "
 037:
\n", + "
+038: cdef int end_cond(double phi, double pi, double N, double phi_end):
\n", + "
static int __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_end_cond(double __pyx_v_phi, CYTHON_UNUSED double __pyx_v_pi, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_phi_end) {\n",
+       "  int __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+039:     if phi<phi_end:
\n", + "
  __pyx_t_1 = (__pyx_v_phi < __pyx_v_phi_end);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+040:         return 1
\n", + "
    __pyx_r = 1;\n",
+       "    goto __pyx_L0;\n",
+       "
 041:     else:
\n", + "
+042:         return 0
\n", + "
  /*else*/ {\n",
+       "    __pyx_r = 0;\n",
+       "    goto __pyx_L0;\n",
+       "  }\n",
+       "
 043:
\n", + "
 044:
\n", + "
+045: cdef list update(double phi, double pi, double A, double N, double dN, double [:] dW, double [:] noise,
\n", + "
static PyObject *__pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_update(double __pyx_v_phi, double __pyx_v_pi, double __pyx_v_A, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_dN, __Pyx_memviewslice __pyx_v_dW, __Pyx_memviewslice __pyx_v_noise, double __pyx_v_bias_amp) {\n",
+       "  double __pyx_v_phi_old;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_7);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_XDECREF(__pyx_t_9);\n",
+       "  __Pyx_XDECREF(__pyx_t_10);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.update\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 046:                  double bias_amp):
\n", + "
 047:     # Store old phi value to be used in calculating velocity
\n", + "
+048:     phi_old = phi
\n", + "
  __pyx_v_phi_old = __pyx_v_phi;\n",
+       "
 049:
\n", + "
 050:     # Update field position
\n", + "
+051:     phi = phi + (pi + bias_amp*noise[0])*dN + noise[0]*dW[0]
\n", + "
  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 51, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 51, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_4 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 51, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_phi = ((__pyx_v_phi + ((__pyx_v_pi + (__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_1 * __pyx_v_noise.strides[0]) ))))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_4 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 052:
\n", + "
 053:     # Update the velocity
\n", + "
 054:     pi =\\
\n", + "
+055:         pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN + bias_amp*noise[1]*dN + noise[1]*dW[0]
\n", + "
  __pyx_t_5 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V_prime_by_V_cython(__pyx_v_phi_old); if (unlikely(__pyx_t_5 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  __pyx_t_4 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_3 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_pi = (((__pyx_v_pi - (((3.0 - (0.5 * pow(__pyx_v_pi, 2.0))) * (__pyx_v_pi + __pyx_t_5)) * __pyx_v_dN)) + ((__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_4 * __pyx_v_noise.strides[0]) )))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 056:
\n", + "
+057:     if noise[0]>0:
\n", + "
  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 57, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_6 = ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_1 * __pyx_v_noise.strides[0]) ))) > 0.0);\n",
+       "  if (__pyx_t_6) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
 058:         # Calculate the weight. This is the same as the true 1d case with diffusion based bias
\n", + "
+059:         A += bias_amp*(0.5*bias_amp*dN + dW[0])
\n", + "
    __pyx_t_1 = 0;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_1 < 0) {\n",
+       "      __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 59, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_v_A = (__pyx_v_A + (__pyx_v_bias_amp * (((0.5 * __pyx_v_bias_amp) * __pyx_v_dN) + (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) ))))));\n",
+       "
 060:
\n", + "
+061:     return [phi, pi, A]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_phi); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 61, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_pi); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 61, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_8);\n",
+       "  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_A); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 61, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_9);\n",
+       "  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 61, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_10);\n",
+       "  __Pyx_GIVEREF(__pyx_t_7);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_t_7)) __PYX_ERR(0, 61, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_8);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_8)) __PYX_ERR(0, 61, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_9);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_t_9)) __PYX_ERR(0, 61, __pyx_L1_error);\n",
+       "  __pyx_t_7 = 0;\n",
+       "  __pyx_t_8 = 0;\n",
+       "  __pyx_t_9 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_10);\n",
+       "  __pyx_t_10 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 062:
\n", + "
 063:
\n", + "
 064: #A let's us calculate the bias w=e^-A is the bias, which propagated along with
\n", + "
 065: #the importance sample path.
\n", + "
 066: #See Eq. (33) of arXiv:nucl-th/9809075v1 for more info
\n", + "
+067: cdef list simulation_diff_general_end(double x_in, double y_in, double t_in, double t_f, double dt,
\n", + "
static PyObject *__pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_simulation_diff_general_end(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, PyObject *__pyx_v_rng) {\n",
+       "  double __pyx_v_t;\n",
+       "  double __pyx_v_sqrt_dt;\n",
+       "  double __pyx_v_x;\n",
+       "  double __pyx_v_y;\n",
+       "  double __pyx_v_A;\n",
+       "  int __pyx_v_i;\n",
+       "  int __pyx_v_end_cond_value;\n",
+       "  int __pyx_v_len_rand_nums;\n",
+       "  int __pyx_v_reduced_step;\n",
+       "  int __pyx_v_num_steps;\n",
+       "  __Pyx_memviewslice __pyx_v_rand_nums = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_dW = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_noise = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_4);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.simulation_diff_general_end\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_dW, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_noise, 1);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 068:                                       double bias_amp, double phi_end_in, noise_list, rng):
\n", + "
 069:     cdef double t, sqrt_dt, x, y, z, A
\n", + "
+070:     cdef int i = 0
\n", + "
  __pyx_v_i = 0;\n",
+       "
 071:     cdef int end_cond_value
\n", + "
+072:     cdef int len_rand_nums = 1000
\n", + "
  __pyx_v_len_rand_nums = 0x3E8;\n",
+       "
+073:     cdef int reduced_step = 0
\n", + "
  __pyx_v_reduced_step = 0;\n",
+       "
+074:     cdef int num_steps = 0
\n", + "
  __pyx_v_num_steps = 0;\n",
+       "
 075:
\n", + "
 076:     cdef double [:, :] rand_nums
\n", + "
 077:     cdef double [:] dW
\n", + "
 078:     cdef double [:] noise
\n", + "
 079:
\n", + "
+080:     t = t_in
\n", + "
  __pyx_v_t = __pyx_v_t_in;\n",
+       "
+081:     x = x_in
\n", + "
  __pyx_v_x = __pyx_v_x_in;\n",
+       "
+082:     y = y_in
\n", + "
  __pyx_v_y = __pyx_v_y_in;\n",
+       "
+083:     sqrt_dt = dt**0.5
\n", + "
  __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+084:     A = 0.0
\n", + "
  __pyx_v_A = 0.0;\n",
+       "
+085:     rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_INCREF(__pyx_int_2);\n",
+       "  __Pyx_GIVEREF(__pyx_int_2);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_2)) __PYX_ERR(0, 85, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error);\n",
+       "  __pyx_t_3 = 0;\n",
+       "  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_4) < 0) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__9, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_rand_nums = __pyx_t_5;\n",
+       "  __pyx_t_5.memview = NULL;\n",
+       "  __pyx_t_5.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__9 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__9);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__9);\n",
+       "
+086:     dW = rand_nums[:, 0]
\n", + "
  __pyx_t_6.data = __pyx_v_rand_nums.data;\n",
+       "  __pyx_t_6.memview = __pyx_v_rand_nums.memview;\n",
+       "  __PYX_INC_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __pyx_t_6.shape[0] = __pyx_v_rand_nums.shape[0];\n",
+       "__pyx_t_6.strides[0] = __pyx_v_rand_nums.strides[0];\n",
+       "    __pyx_t_6.suboffsets[0] = -1;\n",
+       "\n",
+       "{\n",
+       "    Py_ssize_t __pyx_tmp_idx = 0;\n",
+       "        Py_ssize_t __pyx_tmp_shape = __pyx_v_rand_nums.shape[1];\n",
+       "    Py_ssize_t __pyx_tmp_stride = __pyx_v_rand_nums.strides[1];\n",
+       "        if (__pyx_tmp_idx < 0)\n",
+       "            __pyx_tmp_idx += __pyx_tmp_shape;\n",
+       "        if (unlikely(!__Pyx_is_valid_index(__pyx_tmp_idx, __pyx_tmp_shape))) {\n",
+       "            PyErr_SetString(PyExc_IndexError,\n",
+       "                            \"Index out of bounds (axis 1)\");\n",
+       "            __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "        }\n",
+       "        __pyx_t_6.data += __pyx_tmp_idx * __pyx_tmp_stride;\n",
+       "}\n",
+       "\n",
+       "__pyx_v_dW = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "
+087:     noise = noise_list[:, 0]
\n", + "
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_tuple__10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 87, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_noise = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_slice__5, __pyx_int_0); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 87, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__10);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__10);\n",
+       "
 088:
\n", + "
+089:     while t<t_f:
\n", + "
  while (1) {\n",
+       "    __pyx_t_7 = (__pyx_v_t < __pyx_v_t_f);\n",
+       "    if (!__pyx_t_7) break;\n",
+       "
 090:         # Scale the step varaince to the dt used
\n", + "
+091:         dW[0] = sqrt_dt*rand_nums[0, i]
\n", + "
    __pyx_t_8 = 0;\n",
+       "    __pyx_t_9 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 91, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 91, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_8 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_9 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
+092:         dW[1] = sqrt_dt*rand_nums[1, i]
\n", + "
    __pyx_t_9 = 1;\n",
+       "    __pyx_t_8 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 92, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 92, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_9 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_8 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
 093:         # Find the noise from the list provided
\n", + "
+094:         noise[0] = noise_list[0, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_0);\n",
+       "    __Pyx_GIVEREF(__pyx_int_0);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_0)) __PYX_ERR(0, 94, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
+095:         noise[1] = noise_list[1, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_1);\n",
+       "    __Pyx_GIVEREF(__pyx_int_1);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_1)) __PYX_ERR(0, 95, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
 096:         # Define the Wiener step, using the pre-drawn random numbers.
\n", + "
 097:         # Step in x and A simultanioues
\n", + "
+098:         [x, y, A] =\\
\n", + "
    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_13 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "    __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    __pyx_v_x = __pyx_t_12;\n",
+       "    __pyx_v_y = __pyx_t_13;\n",
+       "    __pyx_v_A = __pyx_t_14;\n",
+       "
+099:             update(x, y, A, t, dt, dW, noise, bias_amp)
\n", + "
    __pyx_t_4 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_update(__pyx_v_x, __pyx_v_y, __pyx_v_A, __pyx_v_t, __pyx_v_dt, __pyx_v_dW, __pyx_v_noise, __pyx_v_bias_amp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    if (likely(__pyx_t_4 != Py_None)) {\n",
+       "      PyObject* sequence = __pyx_t_4;\n",
+       "      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "      if (unlikely(size != 3)) {\n",
+       "        if (size > 3) __Pyx_RaiseTooManyValuesError(3);\n",
+       "        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "        __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "      }\n",
+       "      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); \n",
+       "      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); \n",
+       "      __Pyx_INCREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_1);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      #else\n",
+       "      __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      #endif\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    } else {\n",
+       "      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "    }\n",
+       "
+100:         t += dt
\n", + "
    __pyx_v_t = (__pyx_v_t + __pyx_v_dt);\n",
+       "
+101:         i += 1
\n", + "
    __pyx_v_i = (__pyx_v_i + 1);\n",
+       "
+102:         num_steps += 1
\n", + "
    __pyx_v_num_steps = (__pyx_v_num_steps + 1);\n",
+       "
 103:         # Using 1/0 for True/False
\n", + "
+104:         end_cond_value = end_cond(x, y, t, phi_end_in)
\n", + "
    __pyx_t_10 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_end_cond(__pyx_v_x, __pyx_v_y, __pyx_v_t, __pyx_v_phi_end_in); if (unlikely(__pyx_t_10 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error)\n",
+       "    __pyx_v_end_cond_value = __pyx_t_10;\n",
+       "
+105:         if end_cond_value == 1:
\n", + "
    __pyx_t_7 = (__pyx_v_end_cond_value == 1);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "
+106:             break
\n", + "
      goto __pyx_L4_break;\n",
+       "
+107:         elif end_cond_value == -1 and reduced_step == 0:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == -1L);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L6_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 0);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L6_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "      goto __pyx_L5;\n",
+       "    }\n",
+       "
+108:             dt = dt/100
\n", + "
      __pyx_v_dt = (__pyx_v_dt / 100.0);\n",
+       "
+109:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+110:             reduced_step = 1
\n", + "
      __pyx_v_reduced_step = 1;\n",
+       "
+111:         elif end_cond_value == 0 and reduced_step == 1:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == 0);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L8_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 1);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L8_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "    __pyx_L5:;\n",
+       "
+112:             dt = 100*dt
\n", + "
      __pyx_v_dt = (100.0 * __pyx_v_dt);\n",
+       "
+113:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+114:             reduced_step = 0
\n", + "
      __pyx_v_reduced_step = 0;\n",
+       "
 115:         # If all of the random numbers have been used up, need to update them.
\n", + "
 116:         # This should still be more efficient than drawing a new random number
\n", + "
 117:         # each time.
\n", + "
+118:         if i == len_rand_nums:
\n", + "
    __pyx_t_7 = (__pyx_v_i == __pyx_v_len_rand_nums);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "  }\n",
+       "  __pyx_L4_break:;\n",
+       "
+119:             rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_4);\n",
+       "      __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_int_2);\n",
+       "      __Pyx_GIVEREF(__pyx_int_2);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_2)) __PYX_ERR(0, 119, __pyx_L1_error);\n",
+       "      __Pyx_GIVEREF(__pyx_t_1);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 119, __pyx_L1_error);\n",
+       "      __pyx_t_1 = 0;\n",
+       "      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_size, __pyx_t_2) < 0) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__9, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "      __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "      __pyx_v_rand_nums = __pyx_t_5;\n",
+       "      __pyx_t_5.memview = NULL;\n",
+       "      __pyx_t_5.data = NULL;\n",
+       "
+120:             i = 0
\n", + "
      __pyx_v_i = 0;\n",
+       "
+121:     return [t, e**(-A)]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_16 = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_e, 0), __pyx_t_double_complex_from_parts((-__pyx_v_A), 0));\n",
+       "  __pyx_t_3 = __pyx_Py_FromSoftComplex(__pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_GIVEREF(__pyx_t_2);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error);\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_4);\n",
+       "  __pyx_t_4 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 122:
\n", + "
 123:
\n", + "
+124: cpdef importance_sampling_simulations_2d_1d_noise(double x_in, double y_in, double t_in, double t_f,
\n", + "
static PyObject *__pyx_pw_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyObject *__pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_importance_sampling_simulations_2d_1d_noise(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, CYTHON_UNUSED int __pyx_skip_dispatch) {\n",
+       "  PyObject *__pyx_v_rng = NULL;\n",
+       "  PyObject *__pyx_v_results = NULL;\n",
+       "  PyObject *__pyx_v_ts = NULL;\n",
+       "  PyObject *__pyx_v_ws = NULL;\n",
+       "  CYTHON_UNUSED int __pyx_7genexpr__pyx_v_i;\n",
+       "  long __pyx_8genexpr1__pyx_v_j;\n",
+       "  int __pyx_8genexpr2__pyx_v_i;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.importance_sampling_simulations_2d_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XDECREF(__pyx_v_rng);\n",
+       "  __Pyx_XDECREF(__pyx_v_results);\n",
+       "  __Pyx_XDECREF(__pyx_v_ts);\n",
+       "  __Pyx_XDECREF(__pyx_v_ws);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "/* Python wrapper */\n",
+       "static PyObject *__pyx_pw_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyMethodDef __pyx_mdef_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise = {\"importance_sampling_simulations_2d_1d_noise\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
+       "static PyObject *__pyx_pw_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       ") {\n",
+       "  double __pyx_v_x_in;\n",
+       "  double __pyx_v_y_in;\n",
+       "  double __pyx_v_t_in;\n",
+       "  double __pyx_v_t_f;\n",
+       "  double __pyx_v_dt;\n",
+       "  int __pyx_v_num_runs;\n",
+       "  double __pyx_v_bias_amp;\n",
+       "  double __pyx_v_phi_end_in;\n",
+       "  PyObject *__pyx_v_noise_list = 0;\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  CYTHON_UNUSED Py_ssize_t __pyx_nargs;\n",
+       "  #endif\n",
+       "  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;\n",
+       "  PyObject *__pyx_r = 0;\n",
+       "  __Pyx_RefNannyDeclarations\n",
+       "  __Pyx_RefNannySetupContext(\"importance_sampling_simulations_2d_1d_noise (wrapper)\", 0);\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  #if CYTHON_ASSUME_SAFE_MACROS\n",
+       "  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);\n",
+       "  #else\n",
+       "  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;\n",
+       "  #endif\n",
+       "  #endif\n",
+       "  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);\n",
+       "  {\n",
+       "    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_in,&__pyx_n_s_y_in,&__pyx_n_s_t_in,&__pyx_n_s_t_f,&__pyx_n_s_dt,&__pyx_n_s_num_runs,&__pyx_n_s_bias_amp,&__pyx_n_s_phi_end_in,&__pyx_n_s_noise_list,0};\n",
+       "  PyObject* values[9] = {0,0,0,0,0,0,0,0,0};\n",
+       "    if (__pyx_kwds) {\n",
+       "      Py_ssize_t kw_args;\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  0: break;\n",
+       "        default: goto __pyx_L5_argtuple_error;\n",
+       "      }\n",
+       "      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  0:\n",
+       "        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_x_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else goto __pyx_L5_argtuple_error;\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1:\n",
+       "        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_y_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 1); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2:\n",
+       "        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 2); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3:\n",
+       "        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_f)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 3); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4:\n",
+       "        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dt)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 4); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5:\n",
+       "        if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_num_runs)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[5]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 5); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6:\n",
+       "        if (likely((values[6] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bias_amp)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[6]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 6); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7:\n",
+       "        if (likely((values[7] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_phi_end_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[7]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 7); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8:\n",
+       "        if (likely((values[8] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_noise_list)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[8]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 8); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "      }\n",
+       "      if (unlikely(kw_args > 0)) {\n",
+       "        const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
+       "        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"importance_sampling_simulations_2d_1d_noise\") < 0)) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "      }\n",
+       "    } else if (unlikely(__pyx_nargs != 9)) {\n",
+       "      goto __pyx_L5_argtuple_error;\n",
+       "    } else {\n",
+       "      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "      values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "      values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "      values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "      values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "    }\n",
+       "    __pyx_v_x_in = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "    __pyx_v_y_in = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_y_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "    __pyx_v_t_in = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_t_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "    __pyx_v_t_f = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_t_f == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "    __pyx_v_dt = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_dt == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 125, __pyx_L3_error)\n",
+       "    __pyx_v_num_runs = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_num_runs == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 125, __pyx_L3_error)\n",
+       "    __pyx_v_bias_amp = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_bias_amp == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 125, __pyx_L3_error)\n",
+       "    __pyx_v_phi_end_in = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_phi_end_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 125, __pyx_L3_error)\n",
+       "    __pyx_v_noise_list = values[8];\n",
+       "  }\n",
+       "  goto __pyx_L6_skip;\n",
+       "  __pyx_L5_argtuple_error:;\n",
+       "  __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, __pyx_nargs); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "  __pyx_L6_skip:;\n",
+       "  goto __pyx_L4_argument_unpacking_done;\n",
+       "  __pyx_L3_error:;\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.importance_sampling_simulations_2d_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return NULL;\n",
+       "  __pyx_L4_argument_unpacking_done:;\n",
+       "  __pyx_r = __pyx_pf_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_importance_sampling_simulations_2d_1d_noise(__pyx_self, __pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list);\n",
+       "  int __pyx_lineno = 0;\n",
+       "  const char *__pyx_filename = NULL;\n",
+       "  int __pyx_clineno = 0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "static PyObject *__pyx_pf_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_importance_sampling_simulations_2d_1d_noise(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list) {\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_importance_sampling_simulations_2d_1d_noise(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 124, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.importance_sampling_simulations_2d_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = NULL;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "/* … */\n",
+       "  __pyx_tuple__22 = PyTuple_Pack(9, __pyx_n_s_x_in, __pyx_n_s_y_in, __pyx_n_s_t_in, __pyx_n_s_t_f, __pyx_n_s_dt, __pyx_n_s_num_runs, __pyx_n_s_bias_amp, __pyx_n_s_phi_end_in, __pyx_n_s_noise_list); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 124, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__22);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__22);\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise, 0, __pyx_n_s_importance_sampling_simulations, NULL, __pyx_n_s_cython_magic_29b43f5a1a5ff71efd, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 124, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_importance_sampling_simulations, __pyx_t_7) < 0) __PYX_ERR(0, 124, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 125:                                                 double dt, int num_runs, double bias_amp, double phi_end_in,
\n", + "
 126:                                                 noise_list):
\n", + "
 127:     # As this variable is global, I can just redfine it hear
\n", + "
+128:     rng = np.random.default_rng()
\n", + "
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 128, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_default_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "  __pyx_t_3 = NULL;\n",
+       "  __pyx_t_4 = 0;\n",
+       "  #if CYTHON_UNPACK_METHODS\n",
+       "  if (likely(PyMethod_Check(__pyx_t_2))) {\n",
+       "    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);\n",
+       "    if (likely(__pyx_t_3)) {\n",
+       "      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      __Pyx_INCREF(function);\n",
+       "      __Pyx_DECREF_SET(__pyx_t_2, function);\n",
+       "      __pyx_t_4 = 1;\n",
+       "    }\n",
+       "  }\n",
+       "  #endif\n",
+       "  {\n",
+       "    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};\n",
+       "    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);\n",
+       "    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  }\n",
+       "  __pyx_v_rng = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "
 129:     results =\\
\n", + "
+130:         [simulation_diff_general_end(x_in, y_in, t_in, t_f, dt, bias_amp, phi_end_in, noise_list, rng)
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "/* … */\n",
+       "      __pyx_t_2 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_simulation_diff_general_end(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, __pyx_v_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 130, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  __pyx_v_results = ((PyObject*)__pyx_t_1);\n",
+       "  __pyx_t_1 = 0;\n",
+       "
+131:          for i in range(num_runs)]
\n", + "
    __pyx_t_4 = __pyx_v_num_runs;\n",
+       "    __pyx_t_5 = __pyx_t_4;\n",
+       "    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "      __pyx_7genexpr__pyx_v_i = __pyx_t_6;\n",
+       "
 132:
\n", + "
+133:     ts, ws = [[results[i][j] for i in range(num_runs)] for j in range(2)]
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    for (__pyx_t_7 = 0; __pyx_t_7 < 2; __pyx_t_7+=1) {\n",
+       "      __pyx_8genexpr1__pyx_v_j = __pyx_t_7;\n",
+       "      { /* enter inner scope */\n",
+       "        __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "        __Pyx_GOTREF(__pyx_t_2);\n",
+       "        __pyx_t_4 = __pyx_v_num_runs;\n",
+       "        __pyx_t_5 = __pyx_t_4;\n",
+       "        for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "          __pyx_8genexpr2__pyx_v_i = __pyx_t_6;\n",
+       "          __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_results, __pyx_8genexpr2__pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_3);\n",
+       "          __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, __pyx_8genexpr1__pyx_v_j, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_8);\n",
+       "          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "          if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;\n",
+       "        }\n",
+       "      } /* exit inner scope */\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  if (1) {\n",
+       "    PyObject* sequence = __pyx_t_1;\n",
+       "    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "    if (unlikely(size != 2)) {\n",
+       "      if (size > 2) __Pyx_RaiseTooManyValuesError(2);\n",
+       "      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "      __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "    }\n",
+       "    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "    __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "    __pyx_t_8 = PyList_GET_ITEM(sequence, 1); \n",
+       "    __Pyx_INCREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_t_8);\n",
+       "    #else\n",
+       "    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_8);\n",
+       "    #endif\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  }\n",
+       "  __pyx_v_ts = __pyx_t_2;\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_v_ws = __pyx_t_8;\n",
+       "  __pyx_t_8 = 0;\n",
+       "
+134:     return ts, ws
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __Pyx_INCREF(__pyx_v_ts);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ts);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_ts)) __PYX_ERR(0, 134, __pyx_L1_error);\n",
+       "  __Pyx_INCREF(__pyx_v_ws);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ws);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ws)) __PYX_ERR(0, 134, __pyx_L1_error);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%cython -a\n", + "\n", + "import numpy as np\n", + "\n", + "cdef double V_0 = 7.903587107979402e-11\n", + "cdef double e = 2.718281828459045\n", + "cdef double pi_num = 3.141592653589793\n", + "cdef double sigma_tilde = 1.59*(10**-2)\n", + "cdef double phi_0 = 2.18812\n", + "cdef double m_squared = 0.25\n", + "cdef double K = 1.17*(10**-3)\n", + "cdef double diff_const_squared = 6.351213422073874e-13\n", + "cdef double phi_end\n", + "cdef double expo\n", + "cdef double fraction\n", + "cdef double fraction3\n", + "cdef double fraction4\n", + "cdef double noise_value\n", + "cdef double bias_value\n", + "cdef double term1\n", + "cdef double term2\n", + "cdef double phi_old\n", + "\n", + "\n", + "cdef double V(double phi):\n", + " expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return V_0*fraction*(1 + K*expo)\n", + "\n", + "cdef double V_prime_by_V_cython(double phi):\n", + " expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction3 = 1/phi - (phi)/(m_squared + phi**2)\n", + " fraction4 = -(phi-phi_0)/(sigma_tilde**2)\n", + " \n", + " term1 = 2*fraction3\n", + " term2 = fraction4*K*expo/(1 + K*expo)\n", + " return term1 + term2\n", + " \n", + "cdef int end_cond(double phi, double pi, double N, double phi_end):\n", + " if phi0:\n", + " # Calculate the weight. This is the same as the true 1d case with diffusion based bias\n", + " A += bias_amp*(0.5*bias_amp*dN + dW[0])\n", + "\n", + " return [phi, pi, A]\n", + "\n", + "\n", + "#A let's us calculate the bias w=e^-A is the bias, which propagated along with \n", + "#the importance sample path.\n", + "#See Eq. (33) of arXiv:nucl-th/9809075v1 for more info\n", + "cdef list simulation_diff_general_end(double x_in, double y_in, double t_in, double t_f, double dt,\n", + " double bias_amp, double phi_end_in, noise_list, rng):\n", + " cdef double t, sqrt_dt, x, y, z, A\n", + " cdef int i = 0\n", + " cdef int end_cond_value\n", + " cdef int len_rand_nums = 1000\n", + " cdef int reduced_step = 0\n", + " cdef int num_steps = 0\n", + " \n", + " cdef double [:, :] rand_nums\n", + " cdef double [:] dW\n", + " cdef double [:] noise\n", + "\n", + " t = t_in\n", + " x = x_in\n", + " y = y_in\n", + " sqrt_dt = dt**0.5\n", + " A = 0.0\n", + " rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))\n", + " dW = rand_nums[:, 0]\n", + " noise = noise_list[:, 0]\n", + "\n", + " while t" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sigma = 0.01\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_sim_start))\n", + "k_in_scale = aH_interpolation(N_sim_start)\n", + "gaussian_pdf = gaussian_pdf_generator(analytical_fpt_std, mean=0)\n", + "epsilon2_sigma_001 = epsilon2_interpolation(find_cg_time(aH_interpolation(N_sim_end), sigma, N_sim_end))\n", + "classical_delta_N_pdf_sigma_001 = classical_delta_N_generator(analytical_fpt_std, epsilon2_sigma_001)\n", + "\n", + "for i in range(len(bias_amp_values)):\n", + " # Very important to keep everything as Python objects\n", + " bias_amp = bias_amp_values[i]\n", + " base_file_name = \"IS_data_x_in_2.2_iterations_100000_bias_\"+str(bias_amp)+\"_Gaussian_bump_sigma_\"\\\n", + " +str(sigma)+\"_scale_exited31.13832_1D_noise_bessel.csv\"\n", + " raw_data = pd.read_csv(base_file_name, index_col=0)\n", + "\n", + " # Easier to work with NumPy arrays\n", + " Ns = np.array(raw_data['FPTs'])\n", + " ws = np.array(raw_data['ws'])\n", + "\n", + " if bias_amp==0.:\n", + " bin_centres, heights, errors = fpt.numerics.re_processing(Ns, estimator=\"naive\",\n", + " min_bin_size=100, t_f=65)\n", + " peak_mean = np.mean(Ns)\n", + " print(peak_mean)\n", + " else:\n", + " bin_centres, heights, errors = fpt.numerics.re_processing(Ns, weights=ws, estimator=\"lognormal\",\n", + " min_bin_size=500, t_f=65, display=False)\n", + " bin_centres = np.array(bin_centres) - find_cg_time(k_end_scale_later, sigma, N_sim_end_later)\n", + " if i == 0:\n", + " bin_centres_combined = bin_centres\n", + " bin_centres_combined = np.array(bin_centres_combined)\n", + " heights_combined = heights\n", + " heights_combined = np.array(heights_combined)\n", + " errors_combined = errors\n", + " errors_combined = np.array(errors_combined)\n", + " plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7,\n", + " label=r\"$\\delta \\phi_{\\rm h}$, $\\sigma = 0.01$\",\n", + " color=color[0])\n", + " else:\n", + " bin_centres_combined = np.concatenate((bin_centres_combined, bin_centres))\n", + " heights_combined = np.concatenate((heights_combined, heights))\n", + " errors_combined = np.concatenate((errors_combined, errors), axis=1)\n", + " plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7,\n", + " color=color[0])\n", + "\n", + "\n", + "sort_logic = np.argsort(bin_centres_combined)\n", + "bin_centres_combined = bin_centres_combined[sort_logic]\n", + "plt.plot(bin_centres_combined, gaussian_pdf(bin_centres_combined),\n", + " color=\"k\", label=\"Gaussian\")\n", + "plt.plot(bin_centres_combined,\n", + " classical_delta_N_pdf_sigma_001(bin_centres_combined),\n", + " color=color[0], label=\"Classical $\\delta N$, $\\sigma=0.01$\")\n", + "\n", + "bin_centres_combined_001 = np.copy(bin_centres_combined)\n", + "\n", + "#\n", + "#\n", + "#\n", + "\n", + "sigma = 1.\n", + "epsilon2_sigma_1 = epsilon2_interpolation(find_cg_time(aH_interpolation(N_sim_end), sigma, N_sim_end))\n", + "classical_delta_N_pdf_sigma_1 = classical_delta_N_generator(analytical_fpt_std, epsilon2_sigma_1)\n", + "\n", + "for i in range(len(bias_amp_values)):\n", + " # Very important to keep everything as Python objects\n", + " bias_amp = bias_amp_values[i]\n", + " base_file_name = \"IS_data_x_in_2.2_iterations_100000_bias_\"+str(bias_amp)+\"_Gaussian_bump_sigma_\"\\\n", + " +str(sigma)+\"_scale_exited31.13832_1D_noise_bessel.csv\"\n", + " raw_data = pd.read_csv(base_file_name, index_col=0)\n", + "\n", + " # Easier to work with NumPy arrays\n", + " Ns = np.array(raw_data['FPTs'])\n", + " ws = np.array(raw_data['ws'])\n", + "\n", + " if bias_amp==0.:\n", + " bin_centres, heights, errors = fpt.numerics.re_processing(Ns, estimator=\"naive\",\n", + " min_bin_size=100, t_f=65)\n", + " peak_mean = np.mean(Ns)\n", + " print(peak_mean)\n", + " else:\n", + " bin_centres, heights, errors = fpt.numerics.re_processing(Ns, weights=ws, estimator=\"lognormal\",\n", + " min_bin_size=500, t_f=65, display=False)\n", + " bin_centres = np.array(bin_centres) - find_cg_time(k_end_scale_later, sigma, N_sim_end_later)\n", + " if i == 0:\n", + " bin_centres_combined = bin_centres\n", + " bin_centres_combined = np.array(bin_centres_combined)\n", + " heights_combined = heights\n", + " heights_combined = np.array(heights_combined)\n", + " errors_combined = errors\n", + " errors_combined = np.array(errors_combined)\n", + " plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7,\n", + " label=r\"$\\delta \\phi_{\\rm h}$, $\\sigma = 1$\",\n", + " color=color[1])\n", + " else:\n", + " bin_centres_combined = np.concatenate((bin_centres_combined, bin_centres))\n", + " heights_combined = np.concatenate((heights_combined, heights))\n", + " errors_combined = np.concatenate((errors_combined, errors), axis=1)\n", + " plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7,\n", + " color=color[1])\n", + "\n", + "\n", + "# Need to use log scale to see data in the far tail\n", + "sort_logic = np.argsort(bin_centres_combined)\n", + "bin_centres_combined = bin_centres_combined[sort_logic]\n", + "plt.plot(bin_centres_combined,\n", + " classical_delta_N_pdf_sigma_1(bin_centres_combined),\n", + " color=color[1], label=\"Classical $\\delta N$, $\\sigma=1$\")\n", + "plt.yscale('log')\n", + "plt.legend(fontsize=18)\n", + "plt.xlabel(r'$\\delta \\mathcal{N}$')\n", + "plt.ylabel(r'$P(\\delta \\mathcal{N})$')\n", + "plt.ylim(bottom = 0.6*np.min(heights_combined), top = 1.6*np.max(heights_combined))\n", + "plt.title(r\"Gaussian bump $\\sigma$ comparison\")\n", + "plt.xlim(left = np.min(bin_centres_combined)-0.05, right=np.max(bin_centres_combined)+0.05)\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tails for the $\\sigma=1$ and $\\sigma=0.01$ clearly deviate, nand the classical $\\delta \\mathcal{N}$ does not agree, but there is coincident agreement for the numeriical with $\\sigma=0.01$ and the classical $\\delta \\mathcal{N}$ for $\\sigma=1. Both data sets show clear non-Gaussianity in the tail." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/User guides/Advanced/Gaussian_bump/Gauusian bump potential 3 - direct simulations.ipynb b/User guides/Advanced/Gaussian_bump/Gauusian bump potential 3 - direct simulations.ipynb new file mode 100644 index 0000000..8ed25b6 --- /dev/null +++ b/User guides/Advanced/Gaussian_bump/Gauusian bump potential 3 - direct simulations.ipynb @@ -0,0 +1,4232 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gaussian bump potential 3 - direct simulations\n", + "\n", + "This is the third in a series of notebooks which will run importance sampling for the Gaussian bump potential. Familiarity with stochastic simulations is assumed.\n", + "\n", + "In this notebook we show how to run stochastic simulations and compare the different noise models.\n", + "\n", + "We start as we did before by defining everything we need and loading in the required data\n", + "\n", + "Throughout natural units with $c = 8\\pi M_{\\rm PL} = \\hbar =1$ are used." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import mystyle\n", + "plt.style.use(mystyle.paper_style)\n", + "\n", + "# Need to make sure you have pyfpt installed\n", + "import pyfpt as fpt\n", + "import multiprocessing as mp\n", + "from multiprocessing import Process, Queue\n", + "from timeit import default_timer as timer\n", + "\n", + "from scipy.optimize import root\n", + "from scipy.integrate import trapezoid\n", + "from scipy.interpolate import CubicSpline\n", + "\n", + "# Let us define the different colours used\n", + "color = ['#377eb8', '#ff7f00', '#984ea3','#4daf4a', '#a65628', '#f781bf','#999999', '#e41a1c', '#dede00']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The potential\n", + "This is the [Gaussian bump potential](https://arxiv.org/abs/1911.00057)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def potential(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return V_0*fraction*(1 + K*expo)\n", + "\n", + "def potential_functional_form(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return fraction*(1 + K*expo)\n", + "\n", + "def potential_dif(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction1 = (phi**2)/(m_squared + phi**2)\n", + " fraction2 = (phi)/(m_squared + phi**2) - (phi**3)/((m_squared + phi**2)**2)\n", + " \n", + " term1 = 2*V_0*fraction2*(1 + K*expo)\n", + " term2 = V_0*fraction1*(-K*expo*(phi-phi_0)/(sigma_tilde**2))\n", + " return term1 + term2\n", + "\n", + "# I tested this against an interpolation of my previous derivative\n", + "def potential_ddif(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " square_brackets = 1 + K*expo\n", + " overall_factor = 2*V_0/(m_squared + phi**2)\n", + " \n", + " term1 = -2*potential_dif(phi)*phi/(m_squared + phi**2)\n", + " term2 = overall_factor*(1 - 3*(phi**2)/(m_squared + phi**2) + 2*(phi**4)/((m_squared + phi**2)**2))*\\\n", + " (1 + K*expo)\n", + " term3 = overall_factor*(phi - (phi**3)/(m_squared + phi**2))*(-K*(phi-phi_0)*expo/(sigma_tilde**2))\n", + " term4 = -overall_factor*0.5*phi*K*(3*phi - 2*phi_0)*expo/(sigma_tilde**2)\n", + " term5 = overall_factor*0.5*K*expo*(phi*(phi-phi_0)/(sigma_tilde**2))**2\n", + " \n", + " return term1 + term2 + term3 + term4 + term5\n", + "\n", + "def V_prime_by_V(phi):\n", + " expo = np.exp(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction3 = 1/phi - (phi)/(m_squared + phi**2)\n", + " fraction4 = -(phi-phi_0)/(sigma_tilde**2)\n", + " \n", + " term1 = 2*fraction3\n", + " term2 = fraction4*K*expo/(1 + K*expo)\n", + " return term1 + term2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are shown such that the power spectrum peaks at $5 \\times 10^{-3}$ in the astroid mass gap." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "K = 1.17*(10**-3) # This needs all 3 sig fig\n", + "cmb_power = 2*10**-9\n", + "cmb_phi = 3.0\n", + "phi_0 = 2.18812\n", + "m = 0.5\n", + "m_squared = m**2\n", + "sigma_tilde = 1.59*(10**-2)\n", + "\n", + "V_0 = 12*(np.pi**2)*(cmb_power/potential_functional_form(cmb_phi))*(V_prime_by_V(cmb_phi)**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading in background\n", + "We have already simulated the background, now we can just load it in." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "background_data = pd.read_csv(\"gaussian_bump_dynamics_dynamics\"+\".csv\", index_col=0)\n", + "\n", + "N_values = np.array(background_data[\"N\"])\n", + "phi_values = np.array(background_data[\"phi\"])\n", + "phi_diff_values = np.array(background_data[\"phi_N_diff\"])\n", + "hubble_param_values = np.array(background_data[\"H\"])\n", + "epsilon1_values = np.array(background_data[\"epsilon1\"])\n", + "epsilon2_values = np.array(background_data[\"epsilon2\"])\n", + "nu_squared_values = np.array(background_data[\"nu_squared\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's interpolate over this data." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "hubble_param_interpolation = CubicSpline(N_values, hubble_param_values)\n", + "epsilon1_interpolation = CubicSpline(N_values, epsilon1_values)\n", + "epsilon2_interpolation = CubicSpline(N_values, epsilon2_values)\n", + "nu_squared_interpolation = CubicSpline(N_values, nu_squared_values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are also a few constants and functions we need." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "N_end = N_values[-1]\n", + "\n", + "N_usr_start = 29.84178346243688\n", + "N_end_start = 32.25059795813168\n", + "\n", + "N_sim_start = 31.13831633\n", + "N_sim_end = 39.1497714\n", + "\n", + "a_in = 1.\n", + "\n", + "dN = 0.00023659513392999544" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def find_cg_time(k, sigma, N_exit):\n", + " def exit_time_func(N_cg_exit):\n", + " return k - sigma*aH_interpolation(N_cg_exit)\n", + " N_guess = N_exit + np.log(sigma**-1)\n", + " sol_cg_time = root(exit_time_func, N_guess)\n", + " N_cg_exit = sol_cg_time.x\n", + " return float(N_cg_exit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Direct simulations\n", + "## 2D noise\n", + "We will first investigate a 2D noise model. The simulations are run using Cython compiled locally for efficiency." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext cython" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Content of stderr:\n", + "/home/joe/.cache/ipython/cython/_cython_magic_a340241e5d4139803139c24d6920cbd683898caa.c:17490:15: warning: ‘__pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_V’ defined but not used [-Wunused-function]\n", + "17490 | static double __pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_V(double __pyx_v_phi) {\n", + " | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " Cython: _cython_magic_a340241e5d4139803139c24d6920cbd683898caa.pyx\n", + " \n", + "\n", + "\n", + "

Generated by Cython 3.0.7

\n", + "

\n", + " Yellow lines hint at Python interaction.
\n", + " Click on a line that starts with a \"+\" to see the C code that Cython generated for it.\n", + "

\n", + "
 001:
\n", + "
+002: import numpy as np
\n", + "
  __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 003:
\n", + "
+004: cdef double V_0 = 7.903587107979402e-11
\n", + "
  __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_V_0 = 7.903587107979402e-11;\n",
+       "
+005: cdef double e = 2.718281828459045
\n", + "
  __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_e = 2.718281828459045;\n",
+       "
+006: cdef double pi_num = 3.141592653589793
\n", + "
  __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_pi_num = 3.141592653589793;\n",
+       "
+007: cdef double sigma_tilde = 1.59*(10**-2)
\n", + "
  __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_sigma_tilde = (1.59 * pow(10.0, -2.0));\n",
+       "
+008: cdef double phi_0 = 2.18812
\n", + "
  __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_phi_0 = 2.18812;\n",
+       "
+009: cdef double m_squared = 0.25
\n", + "
  __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_m_squared = 0.25;\n",
+       "
+010: cdef double K = 1.17*(10**-3)
\n", + "
  __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_K = (1.17 * pow(10.0, -3.0));\n",
+       "
+011: cdef double diff_const_squared = 6.351213422073874e-13
\n", + "
  __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_diff_const_squared = 6.351213422073874e-13;\n",
+       "
 012: cdef double phi_end
\n", + "
 013: cdef double expo
\n", + "
 014: cdef double fraction
\n", + "
 015: cdef double fraction3
\n", + "
 016: cdef double fraction4
\n", + "
 017: cdef double noise_value
\n", + "
 018: cdef double term1
\n", + "
 019: cdef double term2
\n", + "
 020: cdef double phi_old
\n", + "
 021:
\n", + "
 022:
\n", + "
+023: cdef double V(double phi):
\n", + "
static double __pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_V(double __pyx_v_phi) {\n",
+       "  __pyx_t_double_complex __pyx_v_expo;\n",
+       "  double __pyx_v_fraction;\n",
+       "  double __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_a340241e5d4139803139c24d6920cbd683898caa.V\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = -1;\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+024:     expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)
\n", + "
  __pyx_t_1 = (__pyx_v_phi - __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_phi_0);\n",
+       "  if (unlikely(__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_sigma_tilde == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 24, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_expo = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_e, 0), __pyx_t_double_complex_from_parts((-0.5 * pow((__pyx_t_1 / __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_sigma_tilde), 2.0)), 0));\n",
+       "
+025:     fraction = (phi**2)/(m_squared + phi**2)
\n", + "
  __pyx_t_1 = pow(__pyx_v_phi, 2.0);\n",
+       "  __pyx_t_2 = (__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_m_squared + pow(__pyx_v_phi, 2.0));\n",
+       "  if (unlikely(__pyx_t_2 == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 25, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_fraction = (__pyx_t_1 / __pyx_t_2);\n",
+       "
+026:     return V_0*fraction*(1 + K*expo)
\n", + "
  __pyx_t_2 = __Pyx_SoftComplexToDouble(__Pyx_c_prod_double(__pyx_t_double_complex_from_parts((__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_V_0 * __pyx_v_fraction), 0), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(1, 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_K, 0), __pyx_v_expo))), 1); if (unlikely(__pyx_t_2 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L1_error)\n",
+       "  __pyx_r = __pyx_t_2;\n",
+       "  goto __pyx_L0;\n",
+       "
 027:
\n", + "
+028: cdef double V_prime_by_V_cython(double phi):
\n", + "
static double __pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_V_prime_by_V_cython(double __pyx_v_phi) {\n",
+       "  __pyx_t_double_complex __pyx_v_expo;\n",
+       "  double __pyx_v_fraction3;\n",
+       "  double __pyx_v_fraction4;\n",
+       "  double __pyx_v_term1;\n",
+       "  __pyx_t_double_complex __pyx_v_term2;\n",
+       "  double __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_a340241e5d4139803139c24d6920cbd683898caa.V_prime_by_V_cython\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = -1;\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+029:     expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)
\n", + "
  __pyx_t_1 = (__pyx_v_phi - __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_phi_0);\n",
+       "  if (unlikely(__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_sigma_tilde == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 29, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_expo = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_e, 0), __pyx_t_double_complex_from_parts((-0.5 * pow((__pyx_t_1 / __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_sigma_tilde), 2.0)), 0));\n",
+       "
+030:     fraction3 = 1/phi - (phi)/(m_squared + phi**2)
\n", + "
  if (unlikely(__pyx_v_phi == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 30, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_1 = (__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_m_squared + pow(__pyx_v_phi, 2.0));\n",
+       "  if (unlikely(__pyx_t_1 == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 30, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_fraction3 = ((1.0 / __pyx_v_phi) - (__pyx_v_phi / __pyx_t_1));\n",
+       "
+031:     fraction4 = -(phi-phi_0)/(sigma_tilde**2)
\n", + "
  __pyx_t_1 = (-(__pyx_v_phi - __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_phi_0));\n",
+       "  __pyx_t_2 = pow(__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_sigma_tilde, 2.0);\n",
+       "  if (unlikely(__pyx_t_2 == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 31, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_fraction4 = (__pyx_t_1 / __pyx_t_2);\n",
+       "
 032:
\n", + "
+033:     term1 = 2*fraction3
\n", + "
  __pyx_v_term1 = (2.0 * __pyx_v_fraction3);\n",
+       "
+034:     term2 = fraction4*K*expo/(1 + K*expo)
\n", + "
  __pyx_t_3 = __Pyx_c_prod_double(__pyx_t_double_complex_from_parts((__pyx_v_fraction4 * __pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_K), 0), __pyx_v_expo);\n",
+       "  __pyx_t_4 = __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(1, 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_K, 0), __pyx_v_expo));\n",
+       "  if (unlikely(__Pyx_c_is_zero_double(__pyx_t_4))) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 34, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_term2 = __Pyx_c_quot_double(__pyx_t_3, __pyx_t_4);\n",
+       "
+035:     return term1 + term2
\n", + "
  __pyx_t_2 = __Pyx_SoftComplexToDouble(__Pyx_c_sum_double(__pyx_t_double_complex_from_parts(__pyx_v_term1, 0), __pyx_v_term2), 1); if (unlikely(__pyx_t_2 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L1_error)\n",
+       "  __pyx_r = __pyx_t_2;\n",
+       "  goto __pyx_L0;\n",
+       "
 036:
\n", + "
+037: cdef int end_cond(double phi, double pi, double N, double phi_end):
\n", + "
static int __pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_end_cond(double __pyx_v_phi, CYTHON_UNUSED double __pyx_v_pi, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_phi_end) {\n",
+       "  int __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+038:     if phi<phi_end:
\n", + "
  __pyx_t_1 = (__pyx_v_phi < __pyx_v_phi_end);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+039:         return 1
\n", + "
    __pyx_r = 1;\n",
+       "    goto __pyx_L0;\n",
+       "
 040:     else:
\n", + "
+041:         return 0
\n", + "
  /*else*/ {\n",
+       "    __pyx_r = 0;\n",
+       "    goto __pyx_L0;\n",
+       "  }\n",
+       "
 042:
\n", + "
 043:
\n", + "
+044: cdef list update(double phi, double pi, double A, double N, double dN, double [:] dW, double [:] noise,
\n", + "
static PyObject *__pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_update(double __pyx_v_phi, double __pyx_v_pi, double __pyx_v_A, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_dN, __Pyx_memviewslice __pyx_v_dW, __Pyx_memviewslice __pyx_v_noise, CYTHON_UNUSED double __pyx_v_bias_amp) {\n",
+       "  double __pyx_v_phi_old;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_7);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_XDECREF(__pyx_t_9);\n",
+       "  __Pyx_XDECREF(__pyx_t_10);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_a340241e5d4139803139c24d6920cbd683898caa.update\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 045:                  double bias_amp):
\n", + "
 046:     # Store old phi value to be used in calculating velocity
\n", + "
+047:     phi_old = phi
\n", + "
  __pyx_v_phi_old = __pyx_v_phi;\n",
+       "
 048:     # Update field position
\n", + "
+049:     phi = phi + pi*dN + noise[0]*dW[0] + noise[1]*dW[1]
\n", + "
  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_4 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_5 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_5 < 0) {\n",
+       "    __pyx_t_5 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_5 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_5 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_phi = (((__pyx_v_phi + (__pyx_v_pi * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_1 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_3 * __pyx_v_dW.strides[0]) ))))) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_4 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_5 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 050:
\n", + "
 051:     # Update the velocity
\n", + "
 052:     pi =\\
\n", + "
+053:         pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN +\\
\n", + "
  __pyx_t_6 = __pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_V_prime_by_V_cython(__pyx_v_phi_old); if (unlikely(__pyx_t_6 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 53, __pyx_L1_error)\n",
+       "
+054:         noise[2]*dW[1] + noise[1]*dW[0]
\n", + "
  __pyx_t_5 = 2;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_5 < 0) {\n",
+       "    __pyx_t_5 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_5 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_5 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 54, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_4 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 54, __pyx_L1_error)\n",
+       "  }\n",
+       "/* … */\n",
+       "  __pyx_t_3 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 54, __pyx_L1_error)\n",
+       "  }\n",
+       "/* … */\n",
+       "  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 54, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_pi = (((__pyx_v_pi - (((3.0 - (0.5 * pow(__pyx_v_pi, 2.0))) * (__pyx_v_pi + __pyx_t_6)) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_5 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_4 * __pyx_v_dW.strides[0]) ))))) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) )))));\n",
+       "
+055:     return [phi, pi, A]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_phi); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_pi); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_8);\n",
+       "  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_A); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_9);\n",
+       "  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_10);\n",
+       "  __Pyx_GIVEREF(__pyx_t_7);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_t_7)) __PYX_ERR(0, 55, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_8);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_8)) __PYX_ERR(0, 55, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_9);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_t_9)) __PYX_ERR(0, 55, __pyx_L1_error);\n",
+       "  __pyx_t_7 = 0;\n",
+       "  __pyx_t_8 = 0;\n",
+       "  __pyx_t_9 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_10);\n",
+       "  __pyx_t_10 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 056:
\n", + "
 057:
\n", + "
 058: #A let's us calculate the bias w=e^-A is the bias, which propagated along with
\n", + "
 059: #the importance sample path.
\n", + "
 060: #See Eq. (33) of arXiv:nucl-th/9809075v1 for more info
\n", + "
+061: cdef list simulation_diff_general_end(double x_in, double y_in, double t_in,\\
\n", + "
static PyObject *__pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_simulation_diff_general_end(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, PyObject *__pyx_v_rng) {\n",
+       "  double __pyx_v_t;\n",
+       "  double __pyx_v_sqrt_dt;\n",
+       "  double __pyx_v_x;\n",
+       "  double __pyx_v_y;\n",
+       "  double __pyx_v_A;\n",
+       "  int __pyx_v_i;\n",
+       "  int __pyx_v_end_cond_value;\n",
+       "  int __pyx_v_len_rand_nums;\n",
+       "  int __pyx_v_reduced_step;\n",
+       "  int __pyx_v_num_steps;\n",
+       "  __Pyx_memviewslice __pyx_v_rand_nums = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_dW = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_noise = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_4);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_a340241e5d4139803139c24d6920cbd683898caa.simulation_diff_general_end\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_dW, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_noise, 1);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 062:                           double t_f, double dt, double bias_amp, double phi_end_in, noise_list, rng):
\n", + "
 063:     cdef double t, sqrt_dt, x, y, z, A
\n", + "
+064:     cdef int i = 0
\n", + "
  __pyx_v_i = 0;\n",
+       "
 065:     cdef int end_cond_value
\n", + "
+066:     cdef int len_rand_nums = 1000
\n", + "
  __pyx_v_len_rand_nums = 0x3E8;\n",
+       "
+067:     cdef int reduced_step = 0
\n", + "
  __pyx_v_reduced_step = 0;\n",
+       "
+068:     cdef int num_steps = 0
\n", + "
  __pyx_v_num_steps = 0;\n",
+       "
 069:
\n", + "
 070:     cdef double [:, :] rand_nums
\n", + "
 071:     cdef double [:] dW
\n", + "
 072:     cdef double [:] noise
\n", + "
 073:
\n", + "
+074:     t = t_in
\n", + "
  __pyx_v_t = __pyx_v_t_in;\n",
+       "
+075:     x = x_in
\n", + "
  __pyx_v_x = __pyx_v_x_in;\n",
+       "
+076:     y = y_in
\n", + "
  __pyx_v_y = __pyx_v_y_in;\n",
+       "
+077:     sqrt_dt = dt**0.5
\n", + "
  __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+078:     A = 0.0
\n", + "
  __pyx_v_A = 0.0;\n",
+       "
+079:     rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_INCREF(__pyx_int_2);\n",
+       "  __Pyx_GIVEREF(__pyx_int_2);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_2)) __PYX_ERR(0, 79, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error);\n",
+       "  __pyx_t_3 = 0;\n",
+       "  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_4) < 0) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__9, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_rand_nums = __pyx_t_5;\n",
+       "  __pyx_t_5.memview = NULL;\n",
+       "  __pyx_t_5.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__9 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__9);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__9);\n",
+       "
+080:     dW = rand_nums[:, 0]
\n", + "
  __pyx_t_6.data = __pyx_v_rand_nums.data;\n",
+       "  __pyx_t_6.memview = __pyx_v_rand_nums.memview;\n",
+       "  __PYX_INC_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __pyx_t_6.shape[0] = __pyx_v_rand_nums.shape[0];\n",
+       "__pyx_t_6.strides[0] = __pyx_v_rand_nums.strides[0];\n",
+       "    __pyx_t_6.suboffsets[0] = -1;\n",
+       "\n",
+       "{\n",
+       "    Py_ssize_t __pyx_tmp_idx = 0;\n",
+       "        Py_ssize_t __pyx_tmp_shape = __pyx_v_rand_nums.shape[1];\n",
+       "    Py_ssize_t __pyx_tmp_stride = __pyx_v_rand_nums.strides[1];\n",
+       "        if (__pyx_tmp_idx < 0)\n",
+       "            __pyx_tmp_idx += __pyx_tmp_shape;\n",
+       "        if (unlikely(!__Pyx_is_valid_index(__pyx_tmp_idx, __pyx_tmp_shape))) {\n",
+       "            PyErr_SetString(PyExc_IndexError,\n",
+       "                            \"Index out of bounds (axis 1)\");\n",
+       "            __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "        }\n",
+       "        __pyx_t_6.data += __pyx_tmp_idx * __pyx_tmp_stride;\n",
+       "}\n",
+       "\n",
+       "__pyx_v_dW = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "
+081:     noise = noise_list[:, 2]
\n", + "
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_tuple__10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 81, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 81, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_noise = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_slice__5, __pyx_int_2); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 81, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__10);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__10);\n",
+       "
 082:
\n", + "
+083:     while t<t_f:
\n", + "
  while (1) {\n",
+       "    __pyx_t_7 = (__pyx_v_t < __pyx_v_t_f);\n",
+       "    if (!__pyx_t_7) break;\n",
+       "
 084:         # Scale the step varaince to the dt used
\n", + "
+085:         dW[0] = sqrt_dt*rand_nums[0, i]
\n", + "
    __pyx_t_8 = 0;\n",
+       "    __pyx_t_9 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_8 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_9 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
+086:         dW[1] = sqrt_dt*rand_nums[1, i]
\n", + "
    __pyx_t_9 = 1;\n",
+       "    __pyx_t_8 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_9 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_8 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
 087:         # Find the noise from the list provided
\n", + "
+088:         noise[0] = noise_list[0, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_0);\n",
+       "    __Pyx_GIVEREF(__pyx_int_0);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_0)) __PYX_ERR(0, 88, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 88, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 88, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 88, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
+089:         noise[1] = noise_list[1, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_1);\n",
+       "    __Pyx_GIVEREF(__pyx_int_1);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_1)) __PYX_ERR(0, 89, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 89, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
+090:         noise[2] = noise_list[2, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_2);\n",
+       "    __Pyx_GIVEREF(__pyx_int_2);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_2)) __PYX_ERR(0, 90, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 2;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 90, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
 091:         # Define the Wiener step, using the pre-drawn random numbers.
\n", + "
 092:         # Step in x and A simultanioues
\n", + "
+093:         [x, y, A] =\\
\n", + "
    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_13 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "    __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    __pyx_v_x = __pyx_t_12;\n",
+       "    __pyx_v_y = __pyx_t_13;\n",
+       "    __pyx_v_A = __pyx_t_14;\n",
+       "
+094:             update(x, y, A, t, dt, dW, noise, bias_amp)
\n", + "
    __pyx_t_4 = __pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_update(__pyx_v_x, __pyx_v_y, __pyx_v_A, __pyx_v_t, __pyx_v_dt, __pyx_v_dW, __pyx_v_noise, __pyx_v_bias_amp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    if (likely(__pyx_t_4 != Py_None)) {\n",
+       "      PyObject* sequence = __pyx_t_4;\n",
+       "      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "      if (unlikely(size != 3)) {\n",
+       "        if (size > 3) __Pyx_RaiseTooManyValuesError(3);\n",
+       "        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "        __PYX_ERR(0, 93, __pyx_L1_error)\n",
+       "      }\n",
+       "      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); \n",
+       "      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); \n",
+       "      __Pyx_INCREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_1);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      #else\n",
+       "      __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 93, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      #endif\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    } else {\n",
+       "      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 93, __pyx_L1_error)\n",
+       "    }\n",
+       "
+095:         t += dt
\n", + "
    __pyx_v_t = (__pyx_v_t + __pyx_v_dt);\n",
+       "
+096:         i += 1
\n", + "
    __pyx_v_i = (__pyx_v_i + 1);\n",
+       "
+097:         num_steps += 1
\n", + "
    __pyx_v_num_steps = (__pyx_v_num_steps + 1);\n",
+       "
 098:         # Using 1/0 for True/False
\n", + "
+099:         end_cond_value = end_cond(x, y, t, phi_end_in)
\n", + "
    __pyx_t_10 = __pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_end_cond(__pyx_v_x, __pyx_v_y, __pyx_v_t, __pyx_v_phi_end_in); if (unlikely(__pyx_t_10 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 99, __pyx_L1_error)\n",
+       "    __pyx_v_end_cond_value = __pyx_t_10;\n",
+       "
+100:         if end_cond_value == 1:
\n", + "
    __pyx_t_7 = (__pyx_v_end_cond_value == 1);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "
+101:             break
\n", + "
      goto __pyx_L4_break;\n",
+       "
+102:         elif end_cond_value == -1 and reduced_step == 0:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == -1L);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L6_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 0);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L6_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "      goto __pyx_L5;\n",
+       "    }\n",
+       "
+103:             dt = dt/100
\n", + "
      __pyx_v_dt = (__pyx_v_dt / 100.0);\n",
+       "
+104:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+105:             reduced_step = 1
\n", + "
      __pyx_v_reduced_step = 1;\n",
+       "
+106:         elif end_cond_value == 0 and reduced_step == 1:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == 0);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L8_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 1);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L8_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "    __pyx_L5:;\n",
+       "
+107:             dt = 100*dt
\n", + "
      __pyx_v_dt = (100.0 * __pyx_v_dt);\n",
+       "
+108:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+109:             reduced_step = 0
\n", + "
      __pyx_v_reduced_step = 0;\n",
+       "
 110:         # If all of the random numbers have been used up, need to update them.
\n", + "
 111:         # This should still be more efficient than drawing a new random number
\n", + "
 112:         # each time.
\n", + "
+113:         if i == len_rand_nums:
\n", + "
    __pyx_t_7 = (__pyx_v_i == __pyx_v_len_rand_nums);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "  }\n",
+       "  __pyx_L4_break:;\n",
+       "
+114:             rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_4);\n",
+       "      __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_int_2);\n",
+       "      __Pyx_GIVEREF(__pyx_int_2);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_2)) __PYX_ERR(0, 114, __pyx_L1_error);\n",
+       "      __Pyx_GIVEREF(__pyx_t_1);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 114, __pyx_L1_error);\n",
+       "      __pyx_t_1 = 0;\n",
+       "      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_size, __pyx_t_2) < 0) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__9, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "      __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "      __pyx_v_rand_nums = __pyx_t_5;\n",
+       "      __pyx_t_5.memview = NULL;\n",
+       "      __pyx_t_5.data = NULL;\n",
+       "
+115:             i = 0
\n", + "
      __pyx_v_i = 0;\n",
+       "
+116:     return [t, e**(-A)]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_16 = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_e, 0), __pyx_t_double_complex_from_parts((-__pyx_v_A), 0));\n",
+       "  __pyx_t_3 = __pyx_Py_FromSoftComplex(__pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_GIVEREF(__pyx_t_2);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 116, __pyx_L1_error);\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_4);\n",
+       "  __pyx_t_4 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 117:
\n", + "
 118:
\n", + "
+119: cpdef importance_sampling_simulations_2dim_full(double x_in, double y_in, double t_in, double t_f,
\n", + "
static PyObject *__pyx_pw_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_1importance_sampling_simulations_2dim_full(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyObject *__pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_importance_sampling_simulations_2dim_full(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, CYTHON_UNUSED int __pyx_skip_dispatch) {\n",
+       "  PyObject *__pyx_v_rng = NULL;\n",
+       "  PyObject *__pyx_v_results = NULL;\n",
+       "  PyObject *__pyx_v_ts = NULL;\n",
+       "  PyObject *__pyx_v_ws = NULL;\n",
+       "  CYTHON_UNUSED int __pyx_7genexpr__pyx_v_i;\n",
+       "  long __pyx_8genexpr1__pyx_v_j;\n",
+       "  int __pyx_8genexpr2__pyx_v_i;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_a340241e5d4139803139c24d6920cbd683898caa.importance_sampling_simulations_2dim_full\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XDECREF(__pyx_v_rng);\n",
+       "  __Pyx_XDECREF(__pyx_v_results);\n",
+       "  __Pyx_XDECREF(__pyx_v_ts);\n",
+       "  __Pyx_XDECREF(__pyx_v_ws);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "/* Python wrapper */\n",
+       "static PyObject *__pyx_pw_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_1importance_sampling_simulations_2dim_full(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyMethodDef __pyx_mdef_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_1importance_sampling_simulations_2dim_full = {\"importance_sampling_simulations_2dim_full\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_1importance_sampling_simulations_2dim_full, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
+       "static PyObject *__pyx_pw_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_1importance_sampling_simulations_2dim_full(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       ") {\n",
+       "  double __pyx_v_x_in;\n",
+       "  double __pyx_v_y_in;\n",
+       "  double __pyx_v_t_in;\n",
+       "  double __pyx_v_t_f;\n",
+       "  double __pyx_v_dt;\n",
+       "  int __pyx_v_num_runs;\n",
+       "  double __pyx_v_bias_amp;\n",
+       "  double __pyx_v_phi_end_in;\n",
+       "  PyObject *__pyx_v_noise_list = 0;\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  CYTHON_UNUSED Py_ssize_t __pyx_nargs;\n",
+       "  #endif\n",
+       "  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;\n",
+       "  PyObject *__pyx_r = 0;\n",
+       "  __Pyx_RefNannyDeclarations\n",
+       "  __Pyx_RefNannySetupContext(\"importance_sampling_simulations_2dim_full (wrapper)\", 0);\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  #if CYTHON_ASSUME_SAFE_MACROS\n",
+       "  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);\n",
+       "  #else\n",
+       "  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;\n",
+       "  #endif\n",
+       "  #endif\n",
+       "  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);\n",
+       "  {\n",
+       "    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_in,&__pyx_n_s_y_in,&__pyx_n_s_t_in,&__pyx_n_s_t_f,&__pyx_n_s_dt,&__pyx_n_s_num_runs,&__pyx_n_s_bias_amp,&__pyx_n_s_phi_end_in,&__pyx_n_s_noise_list,0};\n",
+       "  PyObject* values[9] = {0,0,0,0,0,0,0,0,0};\n",
+       "    if (__pyx_kwds) {\n",
+       "      Py_ssize_t kw_args;\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  0: break;\n",
+       "        default: goto __pyx_L5_argtuple_error;\n",
+       "      }\n",
+       "      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  0:\n",
+       "        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_x_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        else goto __pyx_L5_argtuple_error;\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1:\n",
+       "        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_y_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_full\", 1, 9, 9, 1); __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2:\n",
+       "        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_full\", 1, 9, 9, 2); __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3:\n",
+       "        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_f)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_full\", 1, 9, 9, 3); __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4:\n",
+       "        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dt)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_full\", 1, 9, 9, 4); __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5:\n",
+       "        if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_num_runs)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[5]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_full\", 1, 9, 9, 5); __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6:\n",
+       "        if (likely((values[6] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bias_amp)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[6]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_full\", 1, 9, 9, 6); __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7:\n",
+       "        if (likely((values[7] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_phi_end_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[7]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_full\", 1, 9, 9, 7); __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8:\n",
+       "        if (likely((values[8] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_noise_list)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[8]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_full\", 1, 9, 9, 8); __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "        }\n",
+       "      }\n",
+       "      if (unlikely(kw_args > 0)) {\n",
+       "        const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
+       "        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"importance_sampling_simulations_2dim_full\") < 0)) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "      }\n",
+       "    } else if (unlikely(__pyx_nargs != 9)) {\n",
+       "      goto __pyx_L5_argtuple_error;\n",
+       "    } else {\n",
+       "      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "      values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "      values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "      values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "      values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "    }\n",
+       "    __pyx_v_x_in = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "    __pyx_v_y_in = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_y_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "    __pyx_v_t_in = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_t_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "    __pyx_v_t_f = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_t_f == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "    __pyx_v_dt = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_dt == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 120, __pyx_L3_error)\n",
+       "    __pyx_v_num_runs = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_num_runs == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 120, __pyx_L3_error)\n",
+       "    __pyx_v_bias_amp = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_bias_amp == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 120, __pyx_L3_error)\n",
+       "    __pyx_v_phi_end_in = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_phi_end_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 120, __pyx_L3_error)\n",
+       "    __pyx_v_noise_list = values[8];\n",
+       "  }\n",
+       "  goto __pyx_L6_skip;\n",
+       "  __pyx_L5_argtuple_error:;\n",
+       "  __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_full\", 1, 9, 9, __pyx_nargs); __PYX_ERR(0, 119, __pyx_L3_error)\n",
+       "  __pyx_L6_skip:;\n",
+       "  goto __pyx_L4_argument_unpacking_done;\n",
+       "  __pyx_L3_error:;\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_a340241e5d4139803139c24d6920cbd683898caa.importance_sampling_simulations_2dim_full\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return NULL;\n",
+       "  __pyx_L4_argument_unpacking_done:;\n",
+       "  __pyx_r = __pyx_pf_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_importance_sampling_simulations_2dim_full(__pyx_self, __pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list);\n",
+       "  int __pyx_lineno = 0;\n",
+       "  const char *__pyx_filename = NULL;\n",
+       "  int __pyx_clineno = 0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "static PyObject *__pyx_pf_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_importance_sampling_simulations_2dim_full(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list) {\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = __pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_importance_sampling_simulations_2dim_full(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_a340241e5d4139803139c24d6920cbd683898caa.importance_sampling_simulations_2dim_full\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = NULL;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "/* … */\n",
+       "  __pyx_tuple__22 = PyTuple_Pack(9, __pyx_n_s_x_in, __pyx_n_s_y_in, __pyx_n_s_t_in, __pyx_n_s_t_f, __pyx_n_s_dt, __pyx_n_s_num_runs, __pyx_n_s_bias_amp, __pyx_n_s_phi_end_in, __pyx_n_s_noise_list); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__22);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__22);\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_1importance_sampling_simulations_2dim_full, 0, __pyx_n_s_importance_sampling_simulations, NULL, __pyx_n_s_cython_magic_a340241e5d41398031, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_importance_sampling_simulations, __pyx_t_7) < 0) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 120:                                            double dt, int num_runs, double bias_amp, double phi_end_in,
\n", + "
 121:                                                 noise_list):
\n", + "
 122:     # As this variable is global, I can just redfine it hear
\n", + "
+123:     rng = np.random.default_rng()
\n", + "
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_default_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "  __pyx_t_3 = NULL;\n",
+       "  __pyx_t_4 = 0;\n",
+       "  #if CYTHON_UNPACK_METHODS\n",
+       "  if (likely(PyMethod_Check(__pyx_t_2))) {\n",
+       "    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);\n",
+       "    if (likely(__pyx_t_3)) {\n",
+       "      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      __Pyx_INCREF(function);\n",
+       "      __Pyx_DECREF_SET(__pyx_t_2, function);\n",
+       "      __pyx_t_4 = 1;\n",
+       "    }\n",
+       "  }\n",
+       "  #endif\n",
+       "  {\n",
+       "    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};\n",
+       "    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);\n",
+       "    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  }\n",
+       "  __pyx_v_rng = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "
 124:     results =\\
\n", + "
+125:         [simulation_diff_general_end(x_in, y_in, t_in, t_f, dt, bias_amp, phi_end_in, noise_list, rng)\\
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 125, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "/* … */\n",
+       "      __pyx_t_2 = __pyx_f_54_cython_magic_a340241e5d4139803139c24d6920cbd683898caa_simulation_diff_general_end(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, __pyx_v_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 125, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  __pyx_v_results = ((PyObject*)__pyx_t_1);\n",
+       "  __pyx_t_1 = 0;\n",
+       "
+126:          for i in range(num_runs)]
\n", + "
    __pyx_t_4 = __pyx_v_num_runs;\n",
+       "    __pyx_t_5 = __pyx_t_4;\n",
+       "    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "      __pyx_7genexpr__pyx_v_i = __pyx_t_6;\n",
+       "
 127:
\n", + "
 128:
\n", + "
+129:     ts, ws = [[results[i][j] for i in range(num_runs)] for j in range(2)]
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    for (__pyx_t_7 = 0; __pyx_t_7 < 2; __pyx_t_7+=1) {\n",
+       "      __pyx_8genexpr1__pyx_v_j = __pyx_t_7;\n",
+       "      { /* enter inner scope */\n",
+       "        __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error)\n",
+       "        __Pyx_GOTREF(__pyx_t_2);\n",
+       "        __pyx_t_4 = __pyx_v_num_runs;\n",
+       "        __pyx_t_5 = __pyx_t_4;\n",
+       "        for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "          __pyx_8genexpr2__pyx_v_i = __pyx_t_6;\n",
+       "          __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_results, __pyx_8genexpr2__pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_3);\n",
+       "          __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, __pyx_8genexpr1__pyx_v_j, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 129, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_8);\n",
+       "          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "          if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 129, __pyx_L1_error)\n",
+       "          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;\n",
+       "        }\n",
+       "      } /* exit inner scope */\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 129, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  if (1) {\n",
+       "    PyObject* sequence = __pyx_t_1;\n",
+       "    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "    if (unlikely(size != 2)) {\n",
+       "      if (size > 2) __Pyx_RaiseTooManyValuesError(2);\n",
+       "      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "      __PYX_ERR(0, 129, __pyx_L1_error)\n",
+       "    }\n",
+       "    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "    __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "    __pyx_t_8 = PyList_GET_ITEM(sequence, 1); \n",
+       "    __Pyx_INCREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_t_8);\n",
+       "    #else\n",
+       "    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 129, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_8);\n",
+       "    #endif\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  }\n",
+       "  __pyx_v_ts = __pyx_t_2;\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_v_ws = __pyx_t_8;\n",
+       "  __pyx_t_8 = 0;\n",
+       "
+130:     return ts, ws
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __Pyx_INCREF(__pyx_v_ts);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ts);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_ts)) __PYX_ERR(0, 130, __pyx_L1_error);\n",
+       "  __Pyx_INCREF(__pyx_v_ws);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ws);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ws)) __PYX_ERR(0, 130, __pyx_L1_error);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%cython -a\n", + "\n", + "import numpy as np\n", + "\n", + "cdef double V_0 = 7.903587107979402e-11\n", + "cdef double e = 2.718281828459045\n", + "cdef double pi_num = 3.141592653589793\n", + "cdef double sigma_tilde = 1.59*(10**-2)\n", + "cdef double phi_0 = 2.18812\n", + "cdef double m_squared = 0.25\n", + "cdef double K = 1.17*(10**-3)\n", + "cdef double diff_const_squared = 6.351213422073874e-13\n", + "cdef double phi_end\n", + "cdef double expo\n", + "cdef double fraction\n", + "cdef double fraction3\n", + "cdef double fraction4\n", + "cdef double noise_value\n", + "cdef double term1\n", + "cdef double term2\n", + "cdef double phi_old\n", + "\n", + "\n", + "cdef double V(double phi):\n", + " expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return V_0*fraction*(1 + K*expo)\n", + "\n", + "cdef double V_prime_by_V_cython(double phi):\n", + " expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction3 = 1/phi - (phi)/(m_squared + phi**2)\n", + " fraction4 = -(phi-phi_0)/(sigma_tilde**2)\n", + " \n", + " term1 = 2*fraction3\n", + " term2 = fraction4*K*expo/(1 + K*expo)\n", + " return term1 + term2\n", + " \n", + "cdef int end_cond(double phi, double pi, double N, double phi_end):\n", + " if phi" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bin_centres, heights, errors = fpt.numerics.re_processing(Ns, estimator=\"naive\", min_bin_size=100)\n", + "# Apply the delta N formula\n", + "bin_centres = np.array(bin_centres) - find_cg_time(k_end_scale_later, sigma, N_sim_end_later)\n", + "\n", + "plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7, label=\"2D, $\\sigma=$\"+str(sigma),\n", + " color=color[0])\n", + "plt.yscale('log')\n", + "plt.legend(fontsize=18)\n", + "plt.xlabel(r'$\\delta \\mathcal{N}$')\n", + "plt.ylabel(r'$P(\\delta \\mathcal{N})$')\n", + "plt.title(r\"Gaussian bump, $\\delta \\phi_{\\mathrm{h}}$\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can already see some non-Gassianity!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we want to compare this with the Gaussian prediction. To do this we need to load the power spectrum data in and integrate to find the variance." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "matching_data = pd.read_csv(\"gaussian_bump_range_of_R_values_at_different_sigma\"+\".csv\",\n", + " index_col=0)\n", + "\n", + "N_modes = np.array(matching_data[\"N exit\"])\n", + "k_raw_values = np.array(matching_data[\"k\"])\n", + "R_end_values = np.array(matching_data[\"R end\"], dtype=np.complex64)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also need a function to do the integration." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def analytical_fpt_variance_func(power_spectrum, k_values):\n", + " ln_k_values = np.log(k_values)\n", + " return trapezoid(power_spectrum/k_values, x=k_values)\n", + "\n", + "def power_spectrum_func(k, R):\n", + " return (np.abs(R)**2)*(k**3)/(2*np.pi**2)\n", + "\n", + "def gaussian_pdf_generator(std, mean=0):\n", + " def pdf(x):\n", + " expo_term = np.exp(-0.5*((x-mean)/std)**2)\n", + " norm = 1/(std*(2*np.pi)**0.5)\n", + " return norm*expo_term\n", + " return pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "a_in = 1.\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_sim_start))\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_sim_start))\n", + "k_values_normed = aH_interpolation(N_modes)/aH_interpolation(N_usr_start)\n", + "\n", + "ps_values = power_spectrum_func(k_raw_values, R_end_values)\n", + "\n", + "ps_log_interpolation = CubicSpline(N_modes, np.log(ps_values))\n", + "\n", + "N_values_integrated = np.linspace(N_sim_start, N_sim_end, 600)\n", + "\n", + "k_values_integrated_normed = aH_interpolation(N_values_integrated)/aH_interpolation(N_usr_start)\n", + "ps_values = np.exp(ps_log_interpolation(N_values_integrated))\n", + "\n", + "analytical_fpt_variance = analytical_fpt_variance_func(ps_values, k_values_integrated_normed)\n", + "analytical_fpt_std = analytical_fpt_variance**0.5\n", + "gaussian_pdf = gaussian_pdf_generator(analytical_fpt_std, mean=0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.10104472578966923" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "analytical_fpt_std" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuMAAAIJCAYAAAAPojNAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAChzklEQVR4nOzdd3yN5/sH8M9zsrdIQhJEiBGxidgjZhXVlJq196hRpUZtba2iRW1S1Cao2oSqHVsEkYiESCQSstc5z+8Pv5xvIkP2c8bn/Xqdl3POM86VR8Z1rnPf1y2IoiiCiIiIiIhKnEzqAIiIiIiItBWTcSIiIiIiiTAZJyIiIiKSCJNxIiIiIiKJMBknIiIiIpIIk3EiIiIiIokwGSciIiIikgiTcSIiIiIiiTAZJyIiIiKSCJNxIiIiIiKJMBknIiIiIpIIk3EiIgkMHjwYgiBAEAQMHjxY6nAk06ZNG+V1mDdvntThkJaYPXu28vuuS5cuUodDWk5X6gCIqHhERETgzJkz8Pb2xu3btxEZGYm3b98iLS0NFhYWKF26NFxcXFC/fn20b98ejRs3hiAIUodNRFoqOTkZXl5eOH36NO7fv4/g4GDExsYiNTUVxsbGKFOmDJydndGuXTsMGDAA1tbWBX4tHx8f5X1XV9eiCJ+owJiME2mY4OBgLFmyBFu2bEFycnK2+7x58wZv3rzB48ePcejQIcyePRvlypXD0KFDMXnyZFhaWpZw1ESkzQ4cOIDx48cjPDw82+2xsbGIjY1FQEAA/vnnH/z000+IiIgocAHh1q1byvtMxklqTMaJNMj+/fsxZMgQxMfHZ3peR0cHjo6OsLKygqmpKd6+fYvw8HCEhYUp93n16hUWLlyI3377DXfu3EHlypVLOnwi0kI7duzAoEGDIIqi8jkbGxs4ODjAwsICcrkc8fHxCA4Oxps3bwAAjo6OBU7EX7x4gYiICOVjJuMkNSbjRBri559/xqxZszI917FjR4wbNw6tW7eGhYVFlmOCg4Nx7tw57Ny5E+fPnwcAxMTEICYmpkRi1maenp7w9PSUOgwiScXGxmLChAnKRLxNmzZYtWoV6tatm+3+4eHh8PLyUiblBZFxiIq9vT3s7OwKfC6iosBknEgDHDp0KFMibmlpib1796JDhw65Hufg4IAhQ4ZgyJAh8PHxwQ8//KBMyomIitvZs2fx7t07AIChoSEOHTqU6zC5smXLYvTo0YV6TY4XJ1XDbipEau7ly5eZunGYm5vjypUrn0zEP+bq6oqzZ89i1apVMDQ0LOIoiYiyev36tfJ+SkoKHj58WOyvyfHipGqYjBOpuWXLliE2Nlb5+I8//oCzs3OBziUIAiZOnJjr8ampqThz5gxmzpyJDh06oGLFijAxMYG+vj7Kli2LRo0aYdKkSbh582a+Xjf9duHChTwdk9+WeKdPn8awYcNQp04dWFpaQldXF0ZGRrC1tUWTJk0wduxYHDp0SFmlK+5z5ae1YXFc85yu3+XLlzF06FA4OzvD1NQU5ubmqFmzJiZMmICAgIA8n78wRFHEP//8g6+//hpVqlSBsbExrK2t4ebmhp9//hmRkZF5Ok9xfl/ltN+pU6fQt29fVK1aFcbGxjAzM4ObmxtWrFiBpKSkLOdJTk7Gxo0b0b59e9jY2EBPTw9ly5ZF586dceDAgQLHXFTXsLg1bdpUeV+hUMDd3R09evTArl27EBwcXCSv8fDhQ0ydOhV169aFpaUlzpw5o9y2YMECVKhQAT169MA///xTJK9HlG8iEamtt2/fisbGxiIAEYDo4uJSrK/3999/i5aWlsrX+9TNw8NDfPfu3SfPm/EYb2/vPMXSunVr5TFz587Ncb+wsLBM+37qZmlpWSLnGjRokHK/QYMG5bhfcV3zj69fQkKCOGLEiFzPra+vL27duvWT586Pj+OIiooSu3btmmsc1tbW4pEjRz557uL8vvp4v/fv34tff/11rnHXq1dPfPv2rfIcDx8+FKtXr57rMb169RJTU1Mlu4YlYcGCBaIgCNnGaWdnJ/bu3Vv08vL65HX42Lt378QBAwaIMpkszz8//fr1y/frEBUWx4wTqbGzZ88iISFB+XjUqFHF+npBQUGIjo5WPjY3N0eVKlWUHQ9ev36NZ8+eKSdjeXl5ITAwEFevXoWRkVGxxpadpKQktG3bFo8ePVI+p6enh+rVq8PGxgaiKCI6OhpPnz5FYmIigA/VueI+V36UxDVXKBT4+uuvlZXB0qVLo3r16tDX18eTJ0+UXXdSUlIwbNgwVKhQAe3bty/01/YxuVyO7t2749KlS8o4nJ2dIYoi/Pz8lJ80REZGokePHti3bx88PDyKPI78ksvl+Oqrr3Du3DkAHyYFVqlSBampqbh3757yZ/Tu3bv4/PPPcfXqVfj7+6N169Z4+/YtAKBatWooV64c3r17h/v370MulwMA9u3bBwcHByxbtizPsajbNRwyZAiOHz+Oa9euoUePHihbtiwePnyIe/fu4fXr19i7dy/27t0LFxcXbN68OVM1PSePHz9G165dM32aU65cORgaGiqfMzMzg5OTE+7du6f8+dm1axfMzc2xbt264vliibIj4RsBIiqkMWPGZKrqPHjwoFhfb/Xq1WL9+vXFVatWiU+fPs12n9DQUHHGjBmirq6uMq7Jkyfnet6MX0NRVjBXrlyp3EdXV1dcsmSJGBMTk2U/uVwu+vj4iLNnzxZr1KhR7OcSxbxXxovrmme8ftbW1iIA0dHRUTxy5Igol8uV+ykUCnHv3r2ZPoGpXr16rufOj4xx2NjYiADEUqVKiX/++WemCmVycrK4adMm0czMTLm/mZmZGBISkuO5i+v76uP9rKysRODDJ1Mfv05cXJw4atSoTLHs3LlTrFOnjghA7Natm+jv75/pmKCgILFp06aZvt+eP3+ep1iK+hoWN09PT9HIyEgsVaqUeObMmUzbFAqFeOLECbFKlSrKeA0NDbPs97Hg4GCxfPnyymPKlSsnHjlyRFQoFOKUKVOUz/fo0UMURVG8d++eWLFiReXzgiCI9+7dK7avmehjTMaJ1FijRo2Uf0BMTEwyJVHFITY2Ns/77t69O1Ns0dHROe5bXElTu3btlPvMmDEjT+dNS0sr9nOJYt6T8eK65h8Pt3F0dBTDwsJy3H/nzp2Z9r906VKe48rNx3EYGhqK169fz3H/CxcuiHp6esr9+/btm+O+JZWMAxBr1KghRkVF5bh/ixYtlPvq6+srh0QoFIps93/z5o1obm6uPGbBggV5jqUor2FxWrZsmfJ79e7duznuFxkZmWk4T/ny5XP8uZDL5aKbm5ty30qVKmV6s+Hu7q7c9tNPPymfv3z5cqZr+O233xbdF0r0CZzASaTGMi5cYW9vD5mseH+kTU1N87xvnz590KxZMwBAfHw8Tp06VVxh5SgkJER5v1WrVnk6RkdHp9jPlR8ldc03btyIsmXL5ri9b9++KF++vPLxv//+m+dz58fUqVPh5uaW4/bWrVtj/PjxyscHDhzIcdXGkrR+/fpcW/KNGTNGeT8lJQWlSpXCunXrcly4xsbGBr169VI+Th92khfqcA137NiBqVOnAgB+//33HPuKA4CVlRVWr16tfPzy5UscP348233XrFmDGzduAPgwjMzLyyvT9+2dO3eU9xs0aKC836xZM9SvX1/5+L///svnV0RUcEzGidRY+nhTANku6pOd48eP47PPPsv1NmjQoCKJL+PYzvQ/kCUp45jpjH+EpT5XcSrINa9ateonW2HKZDK0aNFC+Tjj2PmioqOjg3Hjxn1yvwkTJiiT2NTUVBw9erTIY8kPZ2fnT75Ba9KkSabHffr0gbm5eZ6Pyev1VodrGBAQgLFjxwIA6tSpgyFDhnzymHbt2sHMzEz5OLs3J6mpqVi8eLHy8bhx4zIl+YGBgZk6HGVMxgGgcePGyvuq8AaPtAcncBKpsYyt0gwMDPJ0THBw8CcrphUrVvzkeSIiInDmzBncu3cPoaGhiImJQXJycqZ9nj17prz/8uXLPMVXlBo1aoR79+4BAObPnw9ra2sMHDgwz9equM5VUMV1zZs3b56n/TJWGDNOKi0qDRo0yLU6n87R0REuLi7w9fUFAFy/fh0jRowo8njyKi8TCm1tbfN9TMaVIfN6vdXhGk6fPh1xcXEAPnxikJdl7WUyGezs7JRtXLNbJfjQoUPKvuUymQzfffddpu0Z+4uXL18eZcqUybS9VKlSyvspKSlZzt+mTRtcvHgRc+fOzVM7VaK8YjJOpMYsLS2Vy0KX1BL2L168wNSpU+Hl5YW0tLQ8H5eX/t1FbeLEidi+fTtSUlKQnJyMkSNH4vvvv0enTp3QunVrNGvWDHXr1s3T8J6iPFd+Ffc1/zhRzImJiYnyfsYuPkWldu3a+do3PZF8+vRpkceSH3m5fsbGxoU6Jq/XW9WvYUBAAA4dOgTgQx/4Hj165PnYjN/72Q0BO3z4sPJ+69atUaFChUzbb9++rbz/cVUcyFzcsLGxyXNcRIXFYSpEaqx06dLK+3mtnI0ePRrih8nbmW55GZpy8+ZN1KtXD/v3789XUgggSwW3JNSqVQt79uzJNO46JiYG+/fvx/jx49GgQQNYWVmhd+/eOHbsmLK9WXGfKz9K4poXpLpfVF9fRlZWVnne19raWnm/OKr0+aGvr18ix+SFql/DI0eOKFt+1qhRI89Jr1wuzzRvo1KlSpm2i6KI8+fPKx+3bds2yzkyJuMNGzbMsj1jG8TKlSvnKS6iosBknEiNZfyD8erVq2L9gxofH4+vvvpKWW3V09PDN998gz179uDBgweIiopCUlJSpgR/7ty5xRZPXnl4eODp06eYNm1apmEW6d69e4d9+/ahW7duaNiwYa5jc4vyXHmhrte8oPKToGZ8AyHFGz1VperXMOPEyPxU8e/du4fU1FTlYxcXl0zbQ0JClJ8SAtkn25+qjGccxpLd8UTFhck4kRrLOGlMFMVinSS5bds25RhkXV1dnD59Gjt27EDv3r1Rq1YtWFpaZqmwpo/vLA7pi6LkhZ2dHZYsWYKQkBA8fvwYGzduxIABA7Ik1Hfu3EHr1q1zXYa7KM/1Kap2zYtbfmLPOCwrr5OX8yI/31eqSBWuYW78/f2V9/MyNyVdxiXsdXR0slS+AwMDMz12dHTM9Dg4OBiRkZHKxx8n448ePUJoaKjycXEsakWUEybjRGrs4z9Ie/fuLbbXOnnypPJ+v3790KZNm08ek/Fj5dzo6ekp72esfuWmoJ8CVK9eHSNGjMD27dsREhKCa9euoWvXrsrtkZGRWLRoUYmfKzvFec1V0fPnz/O8b8bkK6cJiyX5faUqivoaFrWMCW/G/59P2bZtm/J+8+bNs7SRzFgVBwBDQ8NMjzNWxcuWLQt7e/tM23fs2KG8b2trm6X7zcdEUcSmTZvQuHFjmJubw8zMDE2aNMH27dvz9gURZcBknEiNNWrUKFNv3D179mT5o1RUXrx4obyfWw/jdKIo4sqVK3k6d8YWb1FRUZ/cPzk5OVOFrTAaN26MI0eOZPqUoaA90YvyXEDxXnNVdPPmTeV44tykpaV9cvwvIO33lVSK+hoWNV3d//WNCAsLy9Mxe/bswZMnT5SPJ0yYkGWfjxP7jycv5/a1vn//Hps3b1Y+HjVqVK5vFORyOTw8PDBy5Ejcvn0bgiAgLi4O169fx6BBg/Djjz/m6esiSsdknEjNzZgxQ3k/MTERw4cPL5bXyWtlMd3Jkyfx6tWrPO2b8ePq+/fvf3L/Y8eOZdt6rKBkMhm+/PJL5eO8JgnFfa7ivOaqKCwsDN7e3p/c7/jx45kq2K1bt852P6m/r6RQ1NewqGWswOdl4aiwsLBMLQrr1KmT6ecrXcY2kMCHNyUZZRwP/vEQlVmzZimHsFhZWWVaECk7a9euxYULF+Dp6YmYmBi8f/8eISEhyk/FfvnlF8k7/JB6YTJOpOZ69uyJzp07Kx///fffmDBhQp6qY/mR8WPdT/0RTUhIwOTJk/N87oyVqgMHDuQae1JSUp4nKean40fGsbYZu9QUx7nyqjivuaqaNWtWruO2U1NTM1UeK1WqBHd392z3La7vK1VXlNcQ+NBfWxAE5a0wMi4c5e/vj927d+e4b0REBLp27arsHa6rq4tt27Zl29awQYMGmYamrF+/PtM1yGny5pYtW7B27Vrl4xUrVmTqMpOd6OhoeHl5YdCgQcrFwMqXL489e/bAysoKCoUC+/bty/UcRBkxGSdSc4Ig4K+//oKTk5PyudWrV6N9+/Z5ntB57969TH+sspNxfPqBAwdw7NixbPeLiopC165dM32s/Ck9e/ZU3n/69Cl++umnbPeLi4tDr169lL2RP6VOnTrw9PREfHx8rvs9e/Ys0x/k7BKTojxXXhXnNVdV6YvPZFehTkpKwoABA/DgwQPlc7NmzcoxQSyu7ytVV5TXsKiNGDEi02uNHDkSO3fuzJQ4p6amYu/evWjYsKGyoi0IArZs2ZJtFxTgQxeZjO1Z79y5gzFjxiApKQlhYWGZPqFq0KAB3r9/j++//z7TQkfffvstBg4c+MmvoXnz5tn+XJuYmKBTp04AkOn6En0KF/0h0gCWlpbw9vaGh4eH8o+Xt7c3GjdujIYNG6Jt27aoW7curK2tYWpqioSEBLx58wZ+fn44ffo0fHx8MlV+s+usMHLkSCxZsgRxcXFQKBTo3r07BgwYgG7duqFs2bKIjo7GpUuXsHXrVrx9+xbm5ubo0qVLrpWvdO3bt8/0h3fOnDm4ceMG+vXrh/LlyyMmJgbXrl3D5s2bERYWhtq1a0NfXz/TR8/ZefjwIYYMGYJx48ahQ4cOaNy4MWrUqKGsVoeGhuLixYvYvn27clEVfX39TEN/iuNceVWc11wVeXh44MSJE9i2bRuuXbuGESNGoHbt2hBFEffv38eGDRsyjenu2LEjhg0bluP5iuv7SpUV9TUsavXr18f48eOxevVqAB/eCA0YMABTpkxB9erVkZqaCj8/P7x//155jJGREdavX//JRHnu3Lk4cuSIMvHetGkTDhw4AAcHh0z79enTB3fv3s20yM/48ePx22+/5elraNy4cY7b0hcaysscBSIlkYg0RmJiojh+/HhRX19fBJDvm5GRkThr1iwxNjY22/MfPHhQ1NXV/eR5TExMxOPHj4tz585VPte6detcY3/48KFobW39yXNXqlRJfP78udi6dWvlc3Pnzs32nPn9+g0NDcWDBw8W+7lEURQHDRqk3HfQoEE57ldc1zwv1+9j+fn/zKuP49i+fXuevt6mTZuKMTExnzx/cXxfZRd3XmR8PW9v70/u7+3tnemYvMZS1NfQ2dlZeUzdunXz9LXmRi6Xi99++60ok8k+GWPr1q3Fhw8f5vnct2/fFitUqJDnn1NbW1vxr7/+ytO5069zbv/f6T8jRfXzQdqBw1SINIihoSFWr16NgIAATJ48GVWqVMnTMW3atMHGjRsRGhqKRYsWZVplMqOvvvoKZ8+eRa1atbLdLpPJ0LFjR9y+fTvTOPa8qFmzJi5fvpxjf18DAwMMGTIEd+7cydJDOCdr167F559/DjMzs1z3MzQ0RJ8+ffDgwQN89dVXxX6u/CjOa66KBgwYAG9vb9SrVy/b7aamppg9eza8vb0/+X8BFM/3laorymv45s0bPH78WPl4zpw5hY5PJpPh999/x82bN/Htt98qe+br6emhTJkycHV1xffff4+rV6/iwoULqFmzZp7PXb9+fTx8+BA//fQTGjZsiFKlSmXarqurC3t7e3Tq1Alr165FQEAA+vXrV+iviagwBFEshjWNiUhlvHz5Enfu3EFERATevn2LtLQ0lCpVCpaWlnB2dkatWrUytRvLC1EUcfv2bfj4+ODt27cwMzODnZ0dWrRoAVtb20LHHBAQgP/++w9hYWEwMDCAg4MD3N3ds/QWziu5XI5Hjx7h6dOnePnyJeLi4qCjowNLS0tUr14drq6uOb4BKc5z5UdxX3NV9ODBA9y9exehoaEwMjKCk5MT2rZtq5w0l19F/X2lKtq0aYOLFy8C+DBUY968ecpthb2GBw4cwNdffw3gw4qZ9+7dK7Hx5UWlbNmyypavR44cwRdffFGg86Rf54+vcUbz5s3D/Pnz0bp1a1y4cKGAEZO24ZhxIg1Xvnz5bJduLwxBENCwYcNi603s5OSUaUJqYeno6KB27dr5Wn67JM6VH8V9zVVRUV/nov6+UgeFvYbpST7woSqubon4y5cvM629kNMEUCIpcZgKERERZSs9Ga9ZsyZ69OghcTT5l7FLlI2NTZEXJoiKApNxIiIiyiIqKgoPHz4EAMyePVvtquJA7itvEqkKDlMhIiKiLEqXLl3ki4eVtNxW3iRSFayMExERkUbKaeVNIlXCyjgRERFpnDdv3iA0NFT5uLDJeF66o8ybNy/HTitEOWFrQzWiUCgQGRkJADA2NlbL8XtEREREmkwUReVKzNbW1pDJch+Iwsq4GomMjETZsmWlDoOIiIiI8iA8PBxlypTJdR+OGSciIiIikggr42rE2NhYeT88PBwmJiYSRkNEREREH4uPj1eOZMiYu+WEybgayThG3MTEhMk4ERERkQrLy/w+DlMhIiIiIpIIk3EiIiIiIokwGSciIiIikgiTcSIiIiIiiTAZJyIiIiKSCJNxIiIiIiKJMBknIiIiIpIIk3EiIiIiIokwGSciIiIikgiTcSIiIiIiiTAZJyIiIiKSCJNxIiIiIiKJ6EodABVMfHx8ludMTEwkiISIiIiICorJuJoqW7ZsludEUZQgEiJSBwnJaThwIxih0YmwtzRCTzcHGBvk7U+AVMcSEWkDQWQGpzbi4+Nhamqa43b+VxLRxyJjk/EyKgELvR4g9F0iZAAUAOxLGWG2R22UL20MazMDyOVyhIWFITg4GCEhIQgJCcHTgCAEhoTiXZUvIDMtA1FUQBAEJL19icDdsyATU6Ejk0FHRwc6OjqQZbgPQQB0jWD9+VTomNsCECEIAvTT4tDcOAR1a1RB/VrV4ejoCAMDgxzjZzJPROomY74WFxf3yZEL/I2mpsLDwzkshUjLFCQx9fIJwZYLARDFD8mw/P+ffxkVj57fLQWenkFqTARCQ0ORlpaW5Xi75r1QwdQGgkwG4f+nGRlaVYCla3ckPDwFE30Z5HI55HI50tLSkJKSArlcjqSUVJRu2B065mUhyP43PSlZxwR/nryO17OnAAAEQUCFChVQuXJlODk5Kf8tXbY89EvZ4fcLLzO9iThy62WmNxFEROqOlXE1kt93WkSkGfJa3c5ILpfj3r17OPjPGZx/qQOFTQ0IOv9L3BXyNETcPY2gf36Hubk5KlSoAAcHB1SoUEF5g3FpeIcZ4+nbNCgy/KWQCUD9iqUx8bPqqGZnnm3MT1/H4LeTT3DnRVSmYwWIsBbfomzkDbx78woBAQEICAhAbGxslnPYNe+FCu6DIMh0lM+lv6kY1sYJI9yrFOh6EhEVJ1bGiYg0THp1O116dftVdCJGb72BYW2cMKBpedy8eROXLl3CpUuXcPnyZWWC+yGpdcl0TkGmA8vqTTF59GBM6Fo/29fd5P0Mjx8GZHleIQK3gqJw8fGbHJPxi4/f4FZQVJbnRQiIEKzxxdffKpNpURTx9u1bBAQEIDAwEAEBAbjz8AmCDJ2Bj+pFokKOpKCbuBZ+DOUSO6NVq1a5Dt8jIlJ1rIyrEVbGibRTblVmk7hgvPvPEw/u3kJKSopym62tLVq2bIn6jZqici1X7H0i4nUeq+rpClKRL4pjgQ9vBDK+AUknKhQI8fbE68v7AAC6urpwc3NDu3bt0LZtWzRt2jTXMehERMUtv/kak3E1wmScSDtt8n6Gzd7PAHwYY51OVMgR4v0nXl/eBycnJ7Rs2RKtWrVCy5Yt4eTklGlfdeumklsyP6FNeQQ98sHNK//i/Pnz8PPzUx5naGiIFi1aoF27dmjeyh0BqdYIe5/EyZ9EVGKYjGswJuNE2ufFixfYuPVP7Nm3HyZtxsPIusL/j5uWwSAtFl0rJOLzDq1Rq6qj1KEWi7wk86GhoTh//jzOnz+Pc+fOITg4GDI9Q9QctgpG1g4QhA/Xy87SGHM4+ZOIihmTcQ3GZJxIO7x//x4HDhzAjh07cPHiRQCATCZDu46dUbPzEJSyr4xKZS1Y6c2GKIr4+a/z2O39ECblqkEQ/tfJRVQoEBN0FwM/b4oZfdtIFyQRaTRO4CQiUkOpqak4deoUduzYgaNHjyIpKQkAULduXQwYMAB9+/aFvb29xFGqPkEQ8HW7RghNNc8yxl4UFUiKDsPMfu44t6Udhg0bBg8PDxgaGkoXMBFpPSbjREQlKOOwC7tSRnDSi8S+3TuxZ88eREREAADs7e3Rv39/DBgwALVr15Y4YvWTUycXQaYDY5uKKFe5Os6dO4dz586hVKlS6N+/P4YOHYoGDRpIEC0RaTsOU1EjHKZCpL4yTUiMToQoKiCKQGJkMHy3TIKhvg569uiBAQMGwN3d/cMqllQgn+rkUs7SCC+ePsTWrVuxa9cuvH//HgBQr149DB06FP3790fp0qUl/RqISH1xzLgGYzJOpL42eT/Dur9vQM/EMtOKlKJCgYQ3zzGqewuM/7yOhBFqnrxM/kxISICXlxe2bNkCb29vAIC+vj48PDwwdOhQtG/fHrIM/19ERJ/CZFyDMRknUk8+Pj6Y/uM8BOg6waZeR8gyrISZl9UsqWQEBgZi27Zt8PT0xMuXLwEAlSpVwqxZszBw4EDo6elJHCERqQMm4xqMyTiR9PLTN/vKlStYuHAhTp48CQBw6DgSto09MvX/Tsfl3VWHXC7HP6fOYu3RG/B/FYmk6DAYRz7EnJk/oF+/ftDV5XQrIsoZk3ENxmScSDp5XVFSFEVcvHgRCxcuxPnz5wF8GIs88fvpqNOsPX464lugFSmpZHz8/ywAUCgUSIj4MLa/sqMDFsyfh169enFcPxFli8m4BmMyTiSdnJZnTze0dWVUTA3EokWL8N9//wEA3NzcMHv2bHTp0kVZDS/MapZU/H47+Ri7r77I8rwoinj78AICvJYAAFxcXDBv3jz06NGDY8qJKBMm4xqMyTiRdJ6+jsFvJ59k6V0tEwB7/Xj4H/gZ9+/cAgC0aNECs2fPRocOHbIdkkKqK6dkPF1r2yT4n/kTXl5eAIA6depg/vz56N69O/+viQhA/vM1vp0nIsqD9N7Vio/KF3K5AleO78X9O7fQtm1beHt7499//0XHjh2ZnKmh/s0roaebAz7+rxMEoKebA6Z+8xkOHTqEW7duoVu3brh//z48PDzg6uqKf/75B6xvEVF+sTKuRlgZJ5JO5j7hCVAo5AAEJEaGwOLZUcz4YSo+b99G6jCpCCQkp2H45usIioiDTBCgEEU42phi8/DGWYYU3bhxA3PnzlVO0nVzc8OsuQsQbVoVr99xKBKRNuIwFQ3GZJxIWsHBwRg/6Tv4vNGBQSlbONmXxvyhn6N5k0ZSh0ZFLL9j+69cuYIZs37Ef5evouawVTCycYBMEABB4CRdIi3DZFyDMRknkkZqaipWrlyJ+fPnIyEhAfXq1cO6devQpEkTqUMjFbLJ+xnWev0HA4uymRd2EkUIgsD2lURaIr/5Gj83U1Px8fFZnmNyTlT0/v33X4wZMwaPHj2CmZkZVq1ahXHjxrHXNGXR2rkM7tavmWWSLxRy2MjeoWW1xpLFRkSqixM41VTZsmVhamqa6UZERSciIgKDBw9G69at8ejRI/Tu3RuPHz/GxIkTmYhTtnKa5AtBwK3zR9H1s/Z49OiRJLERkepiMk5EWichOQ3bLwVi8VFfbL8UiITkNOU2hUKBDRs2oHr16vjzzz9RpUoVnDp1Cnv27IG9vb2EUZOq83CtgPVD3VDO0giCAOh8GDKOsmb6cNCNQsDDW6hXrx7mzZuH5ORkqcMlIhXBMeNqJOMYpPDw8CzDUjhMhSh3n1pFMyrkKWZ+PxHXr1+HgYEBZsyYgR9++AGGhoZSh05qJLvJn0b6Oti+fTu+++47REVFwdnZGRs3bkTLli2lDpeIihgncGowTuAkKpycVtEURRHv/K/Df98CiAoFOnbsiDVr1qBq1aoSREmaLCIiAt999x127twJABg5ciSWLFmCUqVKSRsYERUZLvpDRJQDD9cKaFOjDHQ+XotHIUdKbBTKlCmLvXv34uTJk0zEqVjY2Nhgx44dOHnyJBwdHbFx40bUqFED+/fv54JBRFqKyTgRaRVrM0MoPn5SEFCzqiOu+txDr169uHImFbtOnTrh4cOHmDp1KiIiItCrVy988cUXCAkJkTo0IiphTMaJSGt4+YTgwI1gpCbEQVTIoZCnQVQooJCnIdLcBWefvpc6RNIiJiYmWLp0KW7evImGDRvi2LFjcHFxwe+//w65XC51eERUQjhmXI1wzDhR4QS9fovJEyfg6OFDKNf0KzRq2wVNGtZDh9p2MNTTgbWZAVdIJEmkpaVh9erV+PHHH5GUqkDDr8bCvbMHala2/+Tqn0SkWjiBU4MxGScquHv37qF379548uQJqlevjr1796Ju3bpSh0WkFBmbjBv3H2OB10OIRpaAKELQ0UE5S2PM9qiN8qWN+WaRSA1wAicRUQaiKOKPP/5A48aN8eTJEwwePBi3bt1iIk4qx8snBAtOh0E0toIg04GgowtAwMuoeIzcdAVePhxPTqSJmIwTkcaKjo5Gz549MW7cOOjp6WHHjh3Ytm0bP1UildTauQwaOpaGjizzBGJRoUDy85uoqB8rUWREVJyYjBORRrp69Srq1auHQ4cOoX79+rh16xa++eYbqcMiytHFx29wKygKio8GjwqCDBEv/NC9Y0vs379fmuCIqNgwGScitZTTkvYKhQKLFy9Gy5YtERwcjAkTJuDq1auoVq2axBET5c7DtQLWD3VDOUsjCAKgIwCCAJS3MsGgzxpDnpqCXr16YcKECUhOTpY6XCIqIpzAqUY4gZMo9yXtx7a0xaJp43Dh/FlYWlpi27Zt6N69u9QhE+VLQnIaDtwIRmh0IuwtjZTdVG7evImvv/4aL168QKNGjbBv3z44OjpKHS4RfYTdVDQYk3Gi3Je0D/1vD156/4nmzZtj165dcHBwkCBCouITFRWFwYMH4++//4alpSX+/PNPdOvWTeqwiCgDdlMhIo2WPsntozluEBVy6BlbYPTE73HhwgUm4qSRSpcujSNHjmDp0qWIiYnBF198gR9++AGpqalSh0ZEBcRknIjUSm6T3Mwd66JB91HQ1eUCKaS5BEHA1KlTceHCBdjb22Pp0qVo27YtXr16JXVoRFQATMaJSK2kT3IrbSgql7KHqIBtKQN4TvWAh2sFqUMkKhEtWrTA3bt30aFDB/z333+oV68ezpw5I3VYRJRPTMaJSK1Ymxng0eUT8P6pN0K8PVFJLxqj21fD7vGtUK+iJVcoJK1iY2ODEydOYMGCBXj79i06deqEuXPnQi6XSx0aEeURJ3CqEU7gJG0niiJ++uknzJ49G4aGhti5cyd69OghdVhEKuHcuXPoP3AIZJWaokotVwzo2RX9W1aFsQGHbRGVJHZT0WBMxkmbpaSkYNSoUfD09ISNjQ2OHj2KJk2aSB0WkUpIb/k5d/8dhMUkQ1QoIMhksDU3wPyv66N8aWN+akRUQthNhYg0zrt379C5c2d4enrC2dkZ169fZyJOlIGXTwhGb72B8NhUCIIMMh1dCIIMYe+TMez30/DyCZE6RCLKAZNxIlJpz58/R7NmzXD+/Hm4u7vjypUrqFSpktRhEamUHFt+igrEPveByftn0gRGRJ/EZJyIVFZ6BdzPzw+DBg3CyZMnYWlpKXVYRConx5afMh3EvQnGoF7dsX//fmmCI6JcMRknIpV08OBBtGnTBm/evMGCBQuwbds26OvrSx0WkUpKb/lZztIIggDoCIAgAOVLG2Ny/y7QkQno3bs3Vq5cKXWoRPQRTuBUI5zASdpAFEX8+uuvmDZtGvT09LB161b0799f6rCI1EJCchoO3AhGaHQi7C2N0NPNAcYGurh06RK6d++O6OhoTJo0Cb/++itkMtbjiIoDu6loMCbjpOnS0tIwfvx4bNiwAaVLl4aXlxdatWoldVhEGsHPzw+dO3fGixcv0LNnT+zYsQOGhoZSh0WkcdhNhYjUUkxMDLp164YNGzbAyckJV69eZSJOVIRq1KiBq1evon79+jhw4AA6dOiAqKgoqcMi0npMxolIciEhIWjZsiVOnjyJZs2a4dq1a6hWrZrUYRFpHDs7O1y8eBGdOnXCf//9h+bNmyMoKEjqsIi0GpNxIpLUnTt30KRJE9y/fx+9e/fGuXPnYG1tLXVYRBrLzMwMf//9N4YMGYLHjx+jadOmuHPnjtRhEWktjhlXIxwzTpoiMjYZkbHJuHTxIn7auA+CSWnUq1EVs8f2hbGBHqzNDLhaIFExE0UR8+fPx/z582FqaooDBw6gU6dOUodFpPY4gVODMRknTbHJ+xlWbD0IPTNLGFmVByBAyNDZYVgbJ4xwryJdgERaZPPmzRg9ejQAYNOmTRgyZIjEERGpN07gJCKVZ/HuMeKD78PIqjwEmY4yERcEoKebAzxcK0gcIZH2GD58OI4ePQoDAwMMHToUCxcuBOt0RCWHybiaio+Pz3IjUgfHjx/HwL49oWduA52P+hzrCALS5AoOUSEqYZ9//jlOn7uAqh2HYuv1SAyYswHxSalSh0WkFXSlDoAKpmzZslmeYyWDVN2xY8fQo0cPKBQKtG/TAvdjBSDDt61cFKGrI0NkbDITcqISEhmbjJdRCVhxLRFWTXpBIU+DPwR0WXQUq0a0RfnSxvx5JCpGrIwTUYk4cuQIvvrqKygUCoyY/RvuxZjh4/ePoggcuBEML58QaYIk0kJePiEYvfUGXkUnQgQg6OhCkOkgUTBC3x838OeRqJixMq6mwsPDOYGT1MahQ4fQu3dvCIKAgwcPopl7J0TGJiMpVY6zD8MQGZsEazNDtK9lC0M9HVbhiEpQa+cyuBsUjTsvoqDI+AZZFJEU/RoPjm8D3H+SLD4iTcdkXE2ZmJgwGSe1sH//fvTt2xc6Ojo4dOgQunTpAgDKhLteRUspwyPSehcfv8GtoGxW4pTpIC3hPVYv/x1lLIzw448/lnxwRFqAw1SIqNjs3bsXffv2ha6uLg4fPqxMxIlIdXi4VsD6oW4oZ2kEQQB0hA+djcqXNsZvM8fAxqYMZs+ejZ9//lnqUIk0EvuMqxH2GSd1smvXLgwYMAD6+vo4cuQIOnbsKHVIRJSLhOQ0HLgRjNDoRNhbGqGnmwOMDXTh6+sLd3d3RERE4JdffsH06dOlDpVIpXHRHw3GZJzUxY4dOzB48GAYGBjg6NGjaN++vdQhEVEhPHz4EO7u7oiMjMSSJUswbdo0qUMiUllc9IeIJOXp6YlBgwbB0NAQ//zzDxNxIg1Qq1YtnD9/HlZWVvjhhx+wfPlyqUMi0hhMxomoyGzZsgVDhw6FsbExjh8/Dnd3d6lDIqIiUrt2bZw7dw5WVlaYOnUqVqxYIXVIRBqByTgRFYmNGzdi+PDhMDExwcmTJ9G6dWupQyKiIla3bl2cPXsWpUuXxpQpU7By5UqpQyJSe2xtSET5FhmbnKlP+DWfu7hy5hzMLG2wYdtfcK7bSOoQiaiY1KtXD2fPnkW7du3w3XffQSaTYeLEiVKHRaS2OIFTjXACJ6mKTd7PsOVCAABAFEWICjkEQYBCngodPUMMa+OEEe5VJI6SiIrT7du30a5dO7x79w6//rYa1vU/z9KJhUgb5Tdf408KEeWbh2sFvE9IxcEbLwBBgKDz4VeJro4OejRygIdrBYkjJKLi1qBBAxw4chw9enwJTz89GL99Ch1BgALAkVsvMdujNsqXNuaKukSfwDHjRFQgfgHBkMvlmZ6TAYiMTZImICIqcYFyG1Tq/yuMrCsAECAXAVEEXkUnYvTWG/DyCZE6RCKVx2SciPJtzf5zOHVoJwRByPS8XAQu+L3hH2AiLeHhWgGdmtSEjkwn0/M6AtCmRhl+SkaUBxymQkT5EhISgo2zRyI84i2qt+6BBMEIMgAKAPaljJQfTRORdrA2M4QoAMgwA00hirA2M5QsJiJ1wmSciPIsKioKnTp1wuvQV/jhhx8wZ2bXbJfPJiLt4OUTggM3gpWPRVEBiCIS3r7Cn38HwcJYj5O5iT6B3VTUCLupkJQSExPRvn17XLlyBQMHDoSnp2eWYSpEpF0+bnMaGZuEUP8H+GvhKFhbWeL0+X9RtwaTcdIu7KZCREUuLS0Nffr0wZUrV9C5c2ds3ryZiTgRwdrMQNktpV5Fy/9/tj7KJz7GL7/8gv5ff4n//vsPpUqVkixGIlXHCZxElCtRFDF27FgcPXoUjRo1wv79+6Gnpyd1WESkwn766Sd888038PX1hYeHB5KTk6UOiUhlMRknolzNnz8fmzZtQtWqVfHPP/9weBQRfZIgCNiyZQvatWuHCxcuYPDgwVAoFFKHRaSSmIwTUY42bNiA+fPnw9bWFqdOnYKNjY3UIRGRmtDX18fBgwdRp04d7NmzBzNmzJA6JCKVxGSciLJ1+PBhjB07FmZmZjhx4gQqVaokdUhEpGYsLCxw/PhxlC9fHkuXLsWaNWukDolI5TAZJ6Is/vvvP/Tp0we6uro4fPgw6tWrJ3VIRKSmypUrhxMnTsDCwgITJkyAl5eX1CERqRQm40SUia+vL7p164aUlBTs2LEDbdu2lTokIlJztWrVwuHDh6Gnp4d+/frh6tWrUodEpDKYjBORUkhICD777DO8e/cOq1atQq9evaQOiYg0RJs2beDp6YmkpCR069YNT58+lTokIpXAPuNEWurjxTpeRb7H2UM7ERoeiRHjJ6PfkFFSh0hEGqZv3754+fIlpk2bhs8++wxXr15F2bJlpQ6LSFJcgVONcAVOKkqbvJ9hy4UAAB96iUOhAAQgJS4a+mZWGO5ehctYE1GRE0UREyZMwJo1a9CwYUNcuHBB+beNSBNwBU4iyhMP1wp4n5CKgzeDAQiAjg4AwNDCGj0aOcDDtYK0ARKRRhIEAatWrcLLly9x+PBhdOneA79u3IkLjyMRGZsEazNDtK9lC0M9nUwrfBJpKibjRFrK2swAaXIFICqQcfqIjiAgTa7gH0AiKjY6OjrYtWsXark2x3+X/sXINaehZ2YFQRAAAAduBAMAhrVx4id0pPE4gZNIS0XGJuNFwFMoFJlHqslFEbo6MkTGcvlqIio+RkZGOP7P33DuNBh6ppbKRBwABAHo6cZP6Eg7MBkn0lJrD5zH5tnDkBgZgoxTR0TxQ1XKyydEwuiISBtYWVnD/Yu+H37xZCADEBmbJE1QRCWMw1SItFB0dDT+XPQt0uKj0b1iEixqV8x2rCYRUXHy8gmBz8tEQKaT6Xm5CFzwewOnsmYcpkIaj8k4kZaRy+Xo06cPngcGYNSoUVg4faLUIRGRlvJwrYBGla2w0OsBXkUnQCGXQxBksCtliHk966F8aWOpQyQqdhymQqRlZsyYgdOnT6NFixb4/fffpQ6HiLSYtZkB6lW0xI4xzTC2fTXYpoUixNsTsaeWolY5M35CR1qByTiRFtm1axeWLVuG8uXL48CBA9DX15c6JCIiGBvoYmDLyji4cDCq6Ybj/JmTmDFjhtRhEZUIJuNEWuL27dsYNmwYDA0N4eXlxVXviEjl6OnpYd++fShfvjyWL1+OvXv3Sh0SUbFjMk6kBd68eYMvv/wSSUlJ2LRpE1xdXaUOiYgoW2XKlMGhQ4dgYGCAoUOH4v79+1KHRFSsmIwTabiUlBT07NkTISEhmDJlCr755hupQyIiylWjRo2wbt06JCQkwMPDA1FRUVKHRFRsmIwTabhJkybh0qVL6NChAxYvXix1OEREeTJkyBCMGTMGgYGB6N+/P+RyudQhERULJuNEGmzTpk1Yt24dKleujD179kBXl91MiUh9rFq1Cs2aNcPJkycxZ84cqcMhKhaCKH607BWprPj4eJiamgIA4uLiYGJiInFEpMouX74Md3d36Ovr49q1a6hVq5bUIRER5dvr16/RsGFDvH79GgcOHECPHj2kDokoV/nN11gZJ9JAL1++RI8ePZCamoodO3YwEScitWVnZ4cDBw5AT08PgwcPxqNHj6QOiahIMRkn0jBJSUn46quvEB4ejjlz5sDDw0PqkIiICqVZs2ZYvXo14uLi8OWXX+L9+/dSh0RUZJiME2kQURQxcuRI3Lx5E927d8fcuXOlDomIqEiMHDkSw4YNg7+/P7755hsoFAqpQyIqEkzGS5hcLseSJUtQpUoVGBgYwMnJCYsWLUJaWprUoZEGWLVqFXbs2AEXFxds374dMhl/xIlIMwiCgDVr1sDNzQ3Hjh3DggULpA6JqEjwL3UJ+/bbbzF9+nQ0bNgQa9euRYcOHTBnzhyMGjVK6tBIzZ09exbff/89SpUqhSNHjsDc3FzqkIiIipShoSEOHjyIMmXKYP78+Th69KjUIREVGruplKAHDx6gbt266NWrF/bs2aN8/ocffsDSpUtx8+bNXFdGZDcV+lhkbDIiY5PxIjgEY35cBhhZoEvH9hj2RQsY6unA2swA1mYGUodJRFSk/v33X7Rr1w6GRsbYefgc/BNNEBmbBGszQ7SvZcvffySp/OZrTMZL0KxZs/Dzzz/j8uXLaNasmfL5V69eoXz58pgyZQqWL1+e4/FMxuljm7yfYfP5p0h+/wYGFmUACBAyDE0Z1sYJI9yrSBcgEVEx6fvtHOzbsAy1Rq6FYWl7CIKQaTt//5FU8puvcQWQEuTj4wOZTJal+l2uXDmUK1cOPj4+EkVG6srDtQJOnjqNlxaOEGQ6yucFAejRyAEerhUkjI6IqPj8/tNMRKQaItbSNlMizt9/pG60bsx4QkICTpw4gUWLFuGrr75CxYoVIQgCBEHAvHnz8nSO2NhYzJs3D7Vr14apqSksLCzQqFEj/Prrr0hJScnxuNDQUFhbW0NfXz/LNnt7e7x69aqgXxZpqQc+V3Dn4RPgow+4dAQBaXIFP6IlIo1lY26INp26ZHmev/9I3WhdZfzGjRv4/PPPC3z8ixcv0KZNGwQFBQEAjI2NkZycDB8fH/j4+OCvv/7CuXPnYGlpmeXYhIQEGBhk/8vB0NAQiYmJBY6LtE9ERAT69f8GQuUWkOnoIGM6LhdF6OrIEBmbzD9IRKSxHKzNPvz+y/ALUCGKsLc0ki4oonzSuso4AFhaWqJdu3aYOnUqdu/eDVtb2zwdJ5fL0a1bNwQFBcHOzg5nzpxBfHw8EhISsGfPHpiZmeHOnTvo379/tscbGhoiOTk5221JSUkwNDQs8NdE2kUURQwePBhhr0MhyHQhQvhoO3DgRjC8fEIkipCIqHhFxiajjoMl7EsZQRRFKORpEBUKlDHTRx0HS0TGZv/3lkjVaF1lvGXLloiKisr03PTp0/N0rKenJx48eAAAOHjwIJo2bQoAkMlk6N27NxQKBfr164cTJ07g3LlzaNeuXabjy5cvj8ePHyMlJSXLUJXQ0FA4OTkV9MsiLbNy5UocP34cDV3dsG3H75BDhrMPw7LtJkBEpIm8fEKw5UIAgA89yGNfPcY7/xsIiI3CqPdTMNy9CidwklrQumRcR0fn0zvl4M8//wQAuLu7KxPxjPr06YNZs2bh+fPn2L59e5ZkvGHDhjh9+jR8fHyydFN59eoVevfuXeDYSHvcvHkT06dPh4WFBfbv24NKFa0AAPUqZh0aRUSkqTxcK6Bl9TLKx0mJ9dCr61b4P36E7wZ7wMPVXcLoiPJOK4epFERCQgIuX74MAOjcuXO2+wiCgM8++wwAcPr06Szbe/fuDUEQ8Pvvv2d6Pv0xk3H6lJiYGPTp0wepqanYvHkzKlWqJHVIRESSsDYzgLO9ufJWz6ksvA7sg6GhIX6ePQ1Rr19IHSJRnmhdZbyg/Pz8oFAoAAC1atXKcb/0bWFhYYiKikLp0qWV2+rWrYuRI0diw4YNEEURHTt2hI+PDzZs2IBBgwbBzc0tz/HEx8fnuI39xzWTKIoYNWoUAgMDMXr0aPTs2VPqkIiIVErNmjWxYsUKjB07Fn369MHVq1dzbJxApCqYjOdRaGio8n65cuVy3C/jttDQ0EzJOACsWbMGFStWxObNm3H48GHY29tj3rx5mDFjRr7iKVu2bI7buI6TZtq2bRv27NmDWrVqYcWKFVKHQ0SkkkaPHo3Tp0/j8OHDmDlzJn799VepQyLKFYep5FFsbKzyvrGxcY77ZdyW8Zh0urq6mDFjBgICApCcnIznz59jzpw50NPTK9qASaM8evQI48ePh5GREfbu3QsjI7btIiLKjiAI2Lx5M8qVK4cVK1bg5MmTUodElCsm42oqPDwccXFx2d5IsyQmJqJ3795ITEzE6tWr4eLiInVIREQqzcrKCjt37oQgCBg0aBDCw8OlDokoR0zG88jMzEx5PyEhIcf9Mm7LeExRMzExyfFGmuW7777Dw4cP0adPHwwdOlTqcIiI1EKbNm0wc+ZMvHnzBoMHD1bO+yJSNUzG88je3l55P7dl6zNuy3gMUUEcOHAA69evR+XKlbFhwwYIgvDpg4iICAAwd+5cNG3aFCdPnsRvv/0mdThE2WIynkc1atSATPbhcj18+DDH/dK32draZpm8SZQfQUFBGD58OPT09LB3716Ym5tLHRIRkVrR09PDrl27YG5ujh9++AG3b9+WOiSiLJiM55GxsTGaN28OADlOBhFFEadOnQIAdOzYscRiI82TmpqKvn374v3791i8eDFcXV2lDomISC05Ojpiw4YNyt+rnFtFqobJeD4MGjQIAODt7Y3r169n2b5//34EBgYCAAYOHFisscTHx2e5keaYPXs2rl27hs8//xyTJk2SOhwiIrXWp08fDBkyBE+fPsXEiROlDocoE0HUwqbU0dHRkMvlyscNGjRASEgIpk6dimnTpimfNzQ0hKmpqfJxWloaGjRogAcPHqBcuXL4888/0a5dOygUChw8eBDDhw9HTEwMOnfujOPHjxd53PHx8Zni+ZgW/ldqpNOnT6NTp06wt7fH3bt3YWNjI3VIRERqLy4uDg0bNsTTp0+xcdsOtOz4BZJS5Tj7MAyRsUmwNjNE+1q2MNTTgbWZAazNuFgQFUzGfC0uLu6TzTW0Mhl3dHTEixefXiZ30KBB8PT0zPRcUFAQ3N3dERQUBODD8BWFQoGkpCQAQP369XHu3DlYWloWddhMxrVAWFgY6tati4iICJw/fx5t2rSROiQiIo1x+/ZtNGnSBDr6BnAethYGpbJfQG9YGyeMcK9SwtGRpshvMs5hKvnk6OiI+/fvY86cOahVqxYEQYCenh4aNmyI5cuX49q1a8WSiH8suz7jpN4UCgUGDBiAN2/eYPbs2UzEiYiKWIMGDbB48WIkxcdBJ+w+Pm5QJQhATzcHeLhWkCZA0kpaWRlXV/l9p0XqZdWqVZg8eTJatmyJ8+fPQ1dXV+qQiIg0jkKhwOeff44nutVh2+AziML/6pK6MgFd65fD9C9qShghqTtWxonUTGRsMk5cuo2Zc+ajovs3qDvoJ6w65Y+7L6LxODQGkbHJUodIRKQxZDIZVqzdCJ2UWCg+qkfKRRG6OjL+3qUSxdIbkcQOXg/CtBFDUaX/YhjZVMTN4ATcDA7GgRvBADh2kYioqF0OToFumapIjAyBkbUDIAgQBAGiCBy4EQwLYz3+3qUSw2ScSGKvrx2CSbnqMLb58AchnSAAPRpx7CIRUVHzcK2AltXH4ZcFc3DG+zyc6jRG9y6foX0tO2U3FaKSwmEqRBJ69OgRFi+aD7MyDtCRZf5x1BEEpMkV/KNARFTErM0M4Gxvjo2/LYFtgj/+WzcF9u/vol5FSzjbm/P3LpUoJuNEEklLS8PgwYORnJyMZo3qQ/HRdo5dJCIqXgYGBvD09ISenh6+/fZbhIWFSR0SaSEm42qKK3Cqv6VLl+LmzZuo08QdjxJL4+O+RuljF718QqQJkIhIC9SpUwezZ89GVFQUxowZwzU7qMSxtaEa4aI/muP+/ftwdXWFqakp/r1+G7ompbkSHBGRRFJTU+Hm5oa7d+9i9+7d6NOnj9QhkRrjCpwajMm4Zsj4S/+vv/5Cv379pA6JiEjr3bt3D66urrCwsICvry/Kls1+dU6iT2GfcS3BFTjV188//4y7d+/Cw8MDffv2lTocIiICULduXfz44494+/Ytxo4dywIXlRhWxtUIV+BUf7dv30bjxo1ZeSEiUkEpKSlwc3PDvXv3sHfvXvTq1UvqkEgNsTJOpKKSk5MxePBgpKWlYd26dUzEiYhUjL6+Pjw9PaGrq4tx48bhzZs3UodEWoDJOFEJWbBgAR48eIBevXrh66+/ljocIiLKRr169TBz5kxERkZi/PjxUodDWoDDVNQIh6mor5s3b6JJkyawtraGr68vrK2tpQ6JiIhykJKSAldXVzx48AD79u1jAYXyhcNUiFRMUlISBg0aBIVCgfXr1zMRJyJScenDVXR0dDBu3DhERERIHRJpMCbjRMVszpw58PPzQ//+/eHh4SF1OERElAcNGjTAjBkzEBERgW+//VbqcEiDcZiKGuEwFfVz5coVtGjRAra2tnj48CFKly4tdUhERJRHycnJcHV1xcOHD3HgwAH06NEDkbHJiIxN5kJtlCMu+qPBMv7nhoeHZ/nPZXKuWhISElCvXj34+/vj2LFj6NKli9QhERFRPvn4+KBJkyawsrKCr68vvB68w5YLATnuP6yNE0a4VynBCEnVcMy4lihbtixMTU0z3Ui1zJo1C/7+/hgyZAgTcSIiNeXq6ooffvgBb968wYQJE+DhWgE93RwgCJn3EwSgp5sDPFwrSBMoqS0m40TF4N9//8Vvv/2G8uXLY+XKlVKHQ0REhTBnzhy4uLhg9+7duHT2ONLkCuh8lI3rCALS5AoOUaF8YzKupsLDwxEXF5fpRqohLi4OQ4YMgSiK2LJlCywsLKQOiYiICsHAwACenp6QyWQYNXoMUlOSIP9olK9cFKGrI0NkbLJEUZK6YjKupkxMTLLcSDVMnz4dgYGBGDlyJDp27Ch1OEREVAQaNWqEadOmIeJNOH7/aSY+nnEnisCBG8Hw8gmRJkBSW5zAqUbYTUX1eXt7o23btqhYsSIePHgAMzMzqUMiIqIikpSUhLr16uPpk8dYuXkX0mzrsZsKZcFuKhqMybhqS0pKQp06deDv74+zZ8+iXbt2UodERERF7Nq1a2jevDnKlCkDX19ftqylLPKbr+kW5Ys/ffoUV69eRWhoKCIiIpCUlAQrKyvY2NigRo0aaN68OYyNjYvyJYlUxuLFi+Hv74+BAwcyESci0lBNmjTBlClTsGzZMkyaNAnbt2+XOiRSc4WujF+9ehUbN27EyZMn8ebNm1z31dXVRYMGDdC/f38MGDCAE9vyiZVx1fXkyRPUqVMHpqamePz4MWxsbKQOiYiIikliYiLq16+PJ0+e4OjRo+jWrZvUIZEKKbFhKjt37sTSpUvh6+uLjKcwNTWFlZUVSpcuDSMjI0RFRSEqKgqRkZFQKBQfXlQQYGRkhL59+2LOnDmoUIE9OfOCybhqEkUR7du3x/nz57F582YMGzZM6pCIiKiYXb16Fc2bN4etrS0ePXqEUqVKSR0SqYhiT8YvXLiA77//Hnfu3IEoiihdujR69OiBVq1aoXHjxqhSJftVp+Li4uDj44Pr16/j6NGjuHr1KgDA0NAQEydOxMyZMznZ7ROYjKumHTt2YODAgWjRogUuXrwImYxNioiItMGUKVOwYsUKjB07FmvXrpU6HFIRxZ6My2QyCIKAjh07YvTo0fj888+hp6eX70CDgoKwfft2rF69GlFRUZg3bx5mz56d7/NoEybjqicqKgrVqzvj3bto7Dl+Cc9TLDiznohIS8TFxcHFxQUvX77E9evX0ahRI6lDIhVQrMl4YmIizMzM0K5dO+zdu7dIPpJJSEjAmjVrYGJignHjxhX6fJqMybjqGTFiBDZv3oxyrfqjfJsB2e4zrI0TRrhn/4kRERGpNy8vL3z11Vdo2LAhrl+/Dh0dHalDIonlN1/L1+fpAwYMgEKhwNmzZ7Fq1aoCB5mRsbExpk2bxkQ8n+Lj47PcqGRdunQJmzdvRkVHR4yfPBUfrYwMQQB6ujnAw5VzIoiINNWXX36JLl264NatW1i3bp3U4ZAaylcyfurUKQiCAAsLC3Tu3Lm4YqI8KFu2LExNTTPdqOSkpKRg9OjRAID169YBMl3ofJSN6wgC0uQKDlEhItJggiBg9erVMDIywqxZs/D69WupQyI1k69kvFq1agCAgwcPonHjxsUSEJE6+PXXX/Ho0SP06tULn332GewtjaD4aMSXQhRhb2kkUYRERFRSKlWqhB9//BExMTGYMmWK1OGQmslXMv7bb7/BwMAA+/btAxfulFZ4eDji4uIy3ahkBAYGYsGCBTA3N8eqVasQGZuMOg6WsCv1v8RbEAC7Ukao42CJyNhkCaMlIqKS8P3338PZ2Rm7d+/G2bNnpQ6H1Ei+kvEWLVrg8uXL8PPzQ/Xq1TFv3jzcunWruGKjXJiYmGS5UfETRRHjxo1DUlISfv75Z9jZ2cHLJwSjt97Aq+jEDPsBr6ITMXrrDXj5hEgYMRERlQR9fX388ccfAIBx48YhOZmFGMqbAi/68+LFCxw6dAheXl4ICgpC586d0a1bN7Rv3x6GhoZFHSeB3VRUwb59+9C7d280atQIV69ehY6ODiJjk3OtfrO1IRGR9hgwYAB27tyJBQsWsGWzliqxFTgzioyMxNGjR3HkyBFcvnwZTZs2Rbdu3dC1a1fY29sX9vT0/5iMS+v9+/dwdnbGmzdv4OPjg/r160sdEhERqZjw8HA4OzsjMTERvr6+cHJykjokKmHF2towJ9bW1hg6dCiOHDmCkJAQjBgxAjdv3oSrqytcXV0xf/58DmchtTdr1iyEhYVh4sSJTMSJiChbZcuWxc8//4zk5GSMHz+ec+zok4qkMp4TURRx48YNHDlyBH///TeioqLQtWtXDmcpIFbGpXPjxg00adIE5cqVg5+fH1tJEhFRjuRyOZo2bYqbN29i//796Nmzp9QhUQmSZJhKXgP7+uuvcerUKQCAoaEhZs6ciVmzZpXEy2sEJuPSSEtLQ6NGjXD37l14eXnhyy+/lDokIiJScbdv30ajRo1gZ2cHPz8/mJmZSR0SlRBJhql8yuHDh1GzZk2cOnUKoihCFEV4eHhw1U1SC6tXr8bdu3fxxRdfMBEnIqI8adCgAcaNG4dXr15h3rx5yucjY5PxODQGd19EY/k/fpi+5w6W/+OHuy+i8Tg0hu1wtVCxVsZv3ryJH374ARcvXgTwYdhKmTJlsG7dOnh4eBTXy2osVsZLXkhICGrUqAEAePToERwcHCSOiIiI1EX6xP+IiAjcvn0bderUwSbvZ9hyISDHY4a1ccII9yolGCUVNZWojB8/fhzt27dHkyZNcPHiRYiiCF1dXUyePBlPnz5lIk5qY8KECYiPj8f8+fOZiBMRUb5YWFhg5cqVkMvlGD16NBQKBTxcK6CnmwMEIfO+ggD0dHOAh2sFaYIlyRRZMh4bG4s1a9agevXq6NatG7y9vZUziL/88ks8ePAAv/76K8zNzYvqJYmK1dGjR3H48GHUrVsXEydOlDocIiJSQ71790b79u1x9epVbN26FdZmBkiTK6DzUTauIwhIkyu4LoUWKnQyfv36dYwYMQL29vaYOHEi/P39lUl4jx49cOfOHRw6dAjVqlUrdLBEJSUuLg7jx4+HIAjYsGEDdHV1pQ6JiIjUkCAIWLt2LfT19fHDDz8gMjIS9pZGUHw0SlghirC3NJIoSpJSgZPxtWvXok6dOmjWrBm2bt2K+Ph4iKIIKysrTJkyBU+ePMH+/ftRp06dooyX/l98fHyWGxWdefPmISQkBKNHj0bjxo2lDoeIiNRYtWrVMH36dERFRWHC5Cmo42AJu1L/S7wFAbArZYQ6DpacwKmFCjyB89dff8WVK1dw7949PH/+HKIowtzcHJMmTUKrVq3QpEkTGBsbF3W8Wi3jhIDscGGBonHv3j00bNgQNjY28PPzQ6lSpaQOiYiI1FxSUhJq1aqFgIAAuAxeDjOHWtnuxwmc6k+SPuOxsbG4f/8+7ty5g5s3b+LatWsICgqCq6srOnbsiK5du6Jhw4aFfRmtx2S8+ImiiBYtWuDKlSvYvXs3+vTpI3VIRESkIU6dOoXPPvsMVZ1dcPDkv9DT08uyj7WZAceNqzmVWfTn7du3uHTpEk6dOoUjR47A1NQUo0aNwtChQ2FpaVkcL6nxMv7nhoeHZ/nPZavDwtu9ezf69esHd3d3nDt3DsLH092JiIgKoVevXti/fz+WLl2KqVOnSh0OFQOVScYzUigUOHv2LDw9PXHixAlMmjQJs2bN4qS4fGKf8eIVHx8PZ2dnhIaG4u7du6hdu7bUIRERkYZ59eoVnJ2doVAo4Ofnx7a5Gkgl+oxneRGZDB07dsSuXbvw77//YufOnejatStSU1NL4uWJ8mTZsmV4+fIlRo0axUSciIiKRbly5bBw4UIkJCSwbS4BKKHK+MfOnTuHDh06YNy4cVi9enVJv7zaYmW8+AQHB6N69eowNDSEv78/rK2tpQ6JiIg0VFpaGho1aoS7d+/i2LFj6NKli9QhURFSycp4RvHx8di0aRMAYOfOnSX98kTZmjZtGpKSkjBv3jwm4kREVKx0dXXxxx9/AAC+++47pKSkSBwRSanEk/FVq1Zh3759EAQBZcqUKemXJ8ri0qVL2Lt3L5ydnTF27FipwyEiIi3QtGlT9OvXD0+fPsW6deukDockVOLJePPmzWFlZQVHR0ds2bKlpF+eKBO5XK4cs7dq1aps20wREREVh8WLF8PIyAjz5s3D27dvpQ6HJFLiyXibNm0QERGBgIAAtGjRoqRfnigTT09P3LlzB126dEGnTp2kDoeIiLRIhQoVMHXqVLx79w7z5s2TOhySiCQTOKlgOIGzaMXExKBq1aqIioqCr68vqlWrJnVIRESkZeLj41GtWjWEh4fj/v37cHFxkTokKqT85mts9E1aa9GiRXjz5g2mTJmC0nYV8Tg0Bkmpcpx9GIbI2CRYmxmifS1bGOrpcEU0IiIqFiYmJli8eDEGDhyIKVOm4MSJE1KHRCWsQJXxgwcPYvHixRg9ejSGDRuWadulS5fg5eWFiIgIlC5dGjVq1ECnTp1QqVKlIgtaW7EyXnT8/f1Rs2ZNlCpVCv7+/th3OwJbLgTkuP+wNk4Y4V6lBCMkIiJtoVAo0LhxY/j4+OD48ePo3Lmz1CFRIZRIZXzbtm24fft2lgT7+++/x8qVK7M9pn379vjll1/QoEGDgrwkUZH6/vvvkZqaip9++gkWFhbwcDXE+4RUHLwZjIxvTwUB6NHIAR6uFaQLloiINJpMJsOqVavQokULTJkyBe3bt2dDAS1SoAmcd+/eBQA0adJE+dzRo0exYsUKiKIIR0dHuLm5KZN1URRx5swZNGnShIv8kOTOnDmDo0ePol69ehg6dCgAwNrMAGlyBXQEIdO+OoKANLmCQ1SIiKhYNW/eHL1794afnx82bNggdThUggqUjEdGRsLMzAzGxsbK51auXIlSpUrh9OnTCAgIwNWrV/Hs2TO8fPkSa9asQZUqVZCWloZJkyZh69atRfYFEOVH+vcgAPz222/Q0dFRbrO3NILio1FbClGEvaVRSYZIRERaasmSJTAwMMDcuXMRFRUldThUQgqUjCsUChgY/K9SmJCQgMuXL2Pt2rVo3759pn3t7OwwduxY3L17F8OGDYMoipgwYQJev35duMiJCmD9+vV49OgRvv76a7Rq1Ur5fGRsMuo4WMKu1P8Sb0EA7EoZoY6DJSJjk6UIl4iItEjFihXx/fffIyoqCgsWLJA6HCohBZrAWaZMGcTGxiIxMREA4O3tjc6dOyM2NvaTY5x69+6NAwcOYMaMGVi0aFHBotZSGScEhIeHZ5kQwAmduXv79i2qVq2KxMRE+Pn5wdHRUbltk/czTuAkIiLJxcXFoWrVqoiMjMTDhw9RvXp15bbI2ORci0Ps/KUaSmQCZ9WqVXHt2jU8evQILi4uOHXqFKpWrZqnyQY//fQT9u/fjxMnTjAZL4SyZctmeY4t43M3b948REdH48cff8yUiAOAh2sFtKxeJsdj+cuNiIhKgqmpKX7++WcMHToU33//Pf7++2/lNi+fEBaONFCBKuNz587FwoUL0b59e0ycOBEDBgyAubk5/P3985SQW1paQhRFvHv3riAxa62M77Syw2Q8Z76+vqhbty5sbW3x5MkTfopAREQqS6FQwNXVFXfu3MGpU6fQsWNHAB8q4y+jErDQ6wFeRX8YnSAIgH0pI8z2qI3ypY1ZPFIB+a2MF2jM+JgxY2BhYYFz587hiy++wPv37xEVFYVvv/32k8fK5XIkJSUhJSWlIC9N/y88PBxxcXGZbpQ9URQxefJkyOVyLFmyhIk4ERGptPRWhwDw3XffIS0tDcCHT2nvB0fj9btE5b6iCLx+l4j7wdFMxNVUgZJxW1tb/PPPP6hSpQpEUYS1tTVOnz6NO3fuoFevXggPD8/x2B07diA5ORn29vYFDpo+jA//+EbZ+/vvv5WtNfv16yd1OERERJ/UqlUr9OzZE76+vti0aZPy+dDoRMg+asMrEwSERid+fApSEwUappJRaGgobGxsoKenh4CAALRs2RLv3r1D9+7d0aFDB9SuXRtWVlaIjIzE4cOHsWLFCqSmpmL06NFYu3ZtUX0dWoErcOZfcnIyatWqhWfPnuH69etwc3OTOiQiIqI8CQwMRI0aNZRDgdN0jOD5b2COC9QNblWZ1XEVkN98rdDJ+MeePXsGDw8P+Pr6QvjonRvwYciAlZUV7t27x+p4PjEZz79ly5Zh2rRpGDRoEDw9PaUOh4iIKF+mT5+OJUuWYMqUKajeZTQncKoByZNx4EM1cvXq1di0aRP8/f0zbWvevDk2btyIGjVqFPXLajwm4/kTHh6OqlWrQqFQ4OnTp3zzR0REaicmJgZVq1ZFdHQ0Ll2/A4uyFZCUKsfZh2GIjE2CtZkh2teyhaGeDlsbqgiVSMYzev36NQIDAyGXy+Hk5IRy5coV58tpNCbj+TN8+HBs2bIFP//8M2bMmCF1OERERAWyefNmjBgxAt27d8fhw4elDoc+QeWScSo6TMbz7vbt23B1dYWjoyMePXoEQ0NDqUMiIiIqELlcjoYNG+LevXs4d+4c2rZtK3VIlItib224fPly5cqbReXmzZs4ceJEkZ6TtJcoipg0aRJEUcTy5cuZiBMRkVrT0dHBypUrAUDZqpc0R76T8WnTpqFy5cpYuXJloRft+e+//9C1a1c0adIEN2/eLNS5iNL9/fffuHTpElq3bg0PDw+pwyEiIio0d3d3fPnll7h//z62bt0qdThUhPI9TOXHH3/EypUrkZSUBH19fXTp0gV9+/ZFy5YtUaZMzsuJA0Bqairu3r2Lo0ePYteuXQgKCoIoinBzc8PGjRtRp06dQn0xmo7DVD5NLpejTp06ePToEVsZEhGRRnn27BlcXFxQqlQp+Pv7w8LCQuqQKBslMmb81atXmDlzJnbt2gW5XK5sYVihQgXUrVsXNjY2KF26NAwMDBAdHY2oqCgEBgbi3r17ypU3RVGEk5MTFi5ciD59+uQ3BK3EZPzTtm3bhqFDh6Jnz57Yv3+/1OEQEREVqalTp2L58uWYNm0alixZInU4lI0SncAZGhqKjRs3YuvWrXj58uX/TppDf3EA0NXVRZcuXTBq1Ch06tQp230pe0zGc5eYmIhq1arh9evXePToEapVqyZ1SEREREXq/fv3qFKlCmJiYuDn54fKlStLHRJ9RLJuKg8fPsS///6L69evIzQ0FBEREUhKSoKVlRVsbGzg4uKCVq1aoXnz5jAzMyuKl9Q6TMZzN2/RL5g/eyZ6fzME85asyrKd/VeJiEgTrF+/HmPGjMHXX3+Nffv2SR0OfYStDTUYk/GcRUdHo3zFSkhKSkLd8Vuhb2aVZR+uTEZERJogLS0NderUgZ+fH27evAlXV1epQ6IMir21YXaYz5PUlixZgoTY9xg6ZhIqOZRXPi8IQDlLI6wf6gYP1woSRkhERFQ0dHV18dNPPwEAF7XTAAVOxl+9eoXBgwejTJky0NXVhYWFBdzd3fHnn38yOacS9fLlS/z222+wsrJCo64D8frd//rgiyLw+l0i7gdHc4gKERFpjC+//BJubm44e/Yszp49K3U4VAgFSsYjIyPRpEkT7NixA5GRkRBFEbGxsfj3338xdOhQdOrUCQkJCUUdK1G25s2bh6SkJMyaNQtRiSJkH00KlgkCQqOLdqEqIiIiKQmCgMWLFwP4UB1nIVR9FSgZX7x4MV69egVRFFGzZk0MHjwY/fr1g6OjI0RRxLlz5zB69OiijpUoCz8/P2zbtg0VK1bE2LFjYW9pBMVHv5AUogh7SyOJIiQiIioe7u7u6NixI3x8fHDo0CGpw6ECKlAyfuLECQiCgDFjxihXgtq5cycCAgLwxx9/QBAE/PXXX7h//35Rx0uUycyZM6FQKLBgwQIYGBigp5sDHG1MldtlAuBoY4qebg4SRklERFQ8fvnlFwDArFmzkJaWJnE0VBAFSsaDgoIAAD///HOWPuGjR4/GxIkTIYoi/vrrr0IHSJSTK1eu4PDhw6hduzb69++PyNhkBL9NwLSuLjDQlUFfR8BXjRwwrasLgt8mIDI2WeqQiYiIilSDBg3Qu3dvPHnyBJ6enlKHQwVQoNaGMpkM1tbWePPmTbbbHz16hFq1aqFVq1a4cOFCYWOk/8fWhv8jiiJat26NS5cu4Z9//sHnn3+OTd7PsOVCQI7HsLUhERFpIn9/f9SoUQO2trbw9/eHkRGHZkopv/mabkFfSFc350OrVq0KAHj9+nVBT0+fEB8fn+U5bUrO//nnH1y6dAmtWrVC586dAQAerhXQsnqZHI9hNxUiItJEVatWxfDhw7FhwwasXbsW33//vdQhUT4UuDJua2uL0NDQXPexs7PDq1evChUg/U/Gd1rZ0ZaZ1HK5HHXr1oWvry+uXr2KJk2aSB0SERGRpEJDQ1GlShUYGhoiMDAQpUqVyrQ9MjY51+GaXKW66JRYZTwlJQUPHz6Es7NzjlVybUkOqWTt2LEDvr6++Oqrr5iIExERAbC3t8fEiROxePFiLF++HIsWLcq03csnhEM5VVSBK+PpEzf19PTg4uKCunXrom7duqhXrx7q1q0LKyurT1bPKX8yvtMKDw/P8k5LG4apJCUloVq1anj16hV8fX3h7OwsdUhEREQqITo6GpUrV0ZKSgoCAgJga2ur3JZeGU9KlWPidh+IoogvGlZA+1q2MNTTYWW8COW3Ml6gbirly5eHKIoQRREpKSm4e/cutm/fjilTpqBdu3awtrYGAMTGxmLFihW4ePEiYmNjC/JSlAMTE5MsN22wdu1ahISEYNiwYUzEiYiIMrC0tMT06dORkJCQpTJubWYABytjLD32CMlpCqTIRRy6GYylxx7BwcqYibiEClQZB4CoqCjcunULt27dwu3bt3Hr1i08f/4888kztD0UBAFOTk5wdXVFw4YN0bBhQ7Ru3bpw0WsZbe+m8u7dO1SuXBlJSUnw9/dHuXLlpA6JiIhIpSQkJKBKlSqIiIjA48eP4eTkpNy2/VIg1p/zhyJD5icTgNHtqmJgy8oSRKuZSmzMeOnSpdGhQwd06NBB+dy7d+9w+/ZtZXJ++/ZtPHv2TFlF9/f3x7Nnz7Bnzx4IgsDm9JQvS5cuRXR0NKZPn85EnIiIKBvGxsaYO3cuRo8ejTlz5mRa8yU0OhEyQci0UrVMEBAanShFqPT/ClwZz6vY2FjcuXMnU4L+5MkTiKIIuVxenC+tcbS5Mv7q1StUrVo1x1niRERE9EFqaipq1qwJf39/3LlzB/Xq1QPAynhJKZEx4/lhZmaGVq1aYdKkScouGDExMbh06VJxvzRpkPnz5yMxMRGzZs1iIk5ERJQLPT095ZjxWbNmKZ/v6eYAR5v/tUiWCYCjjSl6ujmUeIz0P8VeGaeio62V8cePH6NmzZooV64cnj59CkNDQ6lDIiIiUmkKhQKNGjXC7du3cfHiRbjUb8xuKiUkv/kak3E1oq3JeI8ePXDo0CFs27YNgwcPljocIiIitXD69Gl06tQJzZo1w6CFnth6MTDHfdlnvOgwGddg2piMX7t2DU2bNkXNmjVx79496OjoSB0SERGRWhBFEe3atYO3tzd27DkA15YdctyXlfGiw2Rcg2lbMi6KIlq3bo1Lly7h6NGj6Natm9QhERERqZXr16+jSZMmLGqVIJWbwElUUMePH8elS5fQokULdO3aVepwiIiI1E7jxo3h4eEBX1/fTG0OSXWwMq5GtKkyLpfLUb9+fTx48ACXL19Gs2bNpA6JiIhILfn5+aFWrVqoUKECnjx5AgMDDkcpTqyMk0bYt28fHjx4gO7duzMRJyIiKoQaNWpg8ODBePHiBTZs2CB1OPQRVsbViLZUxuVyOWrVqoXHjx/j3r17qFOnjtQhERERqbXg4GBUq1YN5ubmCAgIgJmZmdQhaSxWxknt7dmzB48fP0aPHj2YiBMRERUBBwcHjBs3DhEREVixYoXU4VAGrIyrEW2ojKelpaFmzZp4+vQp7t+/j9q1a0sdEhERkUaIjIyEk5MTFAoFAgMDYWNjI3VIGomVcVJru3fvxtOnT9GrVy8m4kREREXI2toaU6dORVxcHH766Sepw6H/x8q4GtH0ynhaWhpq1KiBgIAAPHz4EC4uLlKHREREpFHi4uLg5OSE9+/fIyAgAOXKlZM6JI3DyjiprZ07d+LZs2fo3bs3E3EiIqJiYGpqih9++AHJyclYsmSJ1OEQWBlXK5pcGU9NTYWzszOeP38OX19f1KhRQ+qQiIiINFJCQgIqVarE6ngxYWWc1NKOHTsQGBiIvn37MhEnIiIqRsbGxpg2bRqr4yqClXE1oqmV8dTUVFSvXh0vXrzAo0ePUL16dalDIiIi0mjx8fGoXLky3r9/j8DAQNjb20sdksZgZZzUzp9//onnz5+jX79+TMSJiIhKgImJCaZOncrquApgZVyNaGJlPCUlBdWqVUNISAj8/PxQrVo1qUMiIiLSCvHx8ahUqRJiYmJyrY5HxiYjMjY5x/NYmxnA2syguMJUO/nN13RLIiiinHh6euLFixcYOHAgE3EiIqISZGJigmnTpmHq1KlYunQpVq1ale1+Xj4h2HIhIMfzDGvjhBHuVYopSs3Hyrga0bTKeEpKCqpWrYpXr17h8ePHqFKlCt99ExERlaD06nhsbCwCAwNhZ2eXZZ/0v81JqXJM3O4DURTxRcMKaF/LFoZ6Ovzb/BFWxkltbN26FcHBwRg8eDCqVPnwjprvvomIiEpO+tjxadOmYcmSJdlWx63NDGCsr4Phm68jOU0BADh0Mxi3g6KweXhjGBswnSwMVsbViCZVxpOTk1GlShW8fv0aT548gZOTE4DM49Imbr8JAPhtYCPlcXz3TUREVLTi4+Ph6OiIuLi4HKvj2y8FYv05fygyZI0yARjdrioGtqxcgtGqPnZTIbWwZcsWvHz5EoMGDVIm4sCHZNvZ3hwOVsZIlYtISlXgRkAkHKyM4WxvzkSciIioiKWPHU9KSsLSpUuz3Sc0OhEyQcj0nEwQEBqdWBIhajQm41TikpKS8PPPP0NXVxc//vhjlu0JyWkYvvk6ElLkSE5TYP05/w+Pk9MkiJaIiEjzjR07FtbW1li/fj1ev36dZbu9pREUHw2mUIgi7C2NSipEjcVkXE3Fx8dnuamLzZs349WrVxg8eDAqVaqUZfuBG8EIiohTPlaIQFBEHA7cCC7JMImIiLRG+tjxpKQkLFu2LMv2nm4OcLQxVT6WCYCjjSl6ujmUZJgaiWPG1UjGMUjZUYf/ysTERDg5OSEiIgL+/v5wdHTMss/io744ducV0jIMTNOVCehavxymf1GzBKMlIiLSHnFxcahUqRLi4uLw/Plz2NraZtqekJyGrssvQK4QMayNE3q6OXDyZjY4ZpxU2saNG/H69WsMHTo020Qc4EdhREREUjA1NcX333+fZex4ZGwyHofGIPhtAvR0BBjqyeDmZI3gtwl4HBqTa0ti+jRWxtVIxnda4eHhWd5pqXp3lcTERFSuXBlv377Fs2fP4OCQ/Udb6WPGA998GKqS/lEY2ycREREVr7i4ODg6OiI+Pl5ZHd/k/Yxth/OBfca1hImJicon3x9bv349wsLCMGbMmBwTcQAwNtDF5uGN+VEYERFRCTM1NcXUqVMxffp0LFu2DL/++is8XCugZfUyOR7DTmeFw8q4GlHnPuMJCQmoXLkyoqOjERAQgPLly3/ymC7LvAEA/0x1L+7wiIiI6P+lV8cTEhIQGBiYZew45Y5jxkklrVu3DuHh4RgxYkSuiXj6uLTHoTFIkyuQJlcoH3NcGhERUfFLHzuemJiYbWcVKlqsjKsRda2Mx8fHo1KlSoiJiUFAQADKlSuX474cl0ZERCS92NhYVKpUCQkJCXj+/DnKli0rdUhqg2PGSeX88ccfiIiIwLfffptrIg6A49KIiIhUgJmZGaZMmYKZM2di2bJlWL58udQhaSxWxtWIOlbGM/YsDQgIgL29vdQhERERUR7ExsbC0dERiYmJrI7nA8eMk0pZu3YtIiMjMWrUKCbiREREasTMzEw5dpyV8eLDyrgaUbfKePp4s/j4eAQGBsLOzk7qkIiIiCgfMlbHg4KCUKZMzkNJ6QNWxkllrFu3Dm/fvsWYMWOYiBMREamh9LHj7KxSfFgZVyPqVBlPTExEpUqV8O7dOzx//pzJOBERkZqKiYlBpUqVkJSUhOfPn7M6/gmsjJNK8PT0RHh4OAYPHsxEnIiISI2Zm5tjypQpSEhI4NjxYsDKuBpRl8p4WloaqlatiuDgYPj7+6Ny5cpSh0RERESFEBMTA0dHRyQnJ7M6/gmsjJPk9uzZg6CgIPTp04eJOBERkQbIWB3/9ddfpQ5Ho7AyrkbUoTKuUChQu3ZtPHr0CPfv30ft2rWlDomIiIiKQMbq+IsXL2BtbS11SCqJlXGS1N9//41Hjx6hW7duTMSJiIg0iLm5OSZNmoSEhASsXr1a6nA0BivjakTVK+OiKKJJkya4ceMGrl69iiZNmkgdEhERERWhqKgoODg4QF9fHy9evICZmZnUIakcVsZJMt7e3rhx4wbatGnDRJyIiEgDlS5dGqNGjUJ0dDQ2bdr0yf0jY5PxODQmx1tkbHIJRK3aWBlXI6peGe/QoQPOnj2L06dPo0OHDlKHQ0RERMXg5cuXqFy5MmxsbBAYGAgDA4Mc993k/QxbLgTkuH1YGyeMcK9SHGFKJr/5GpNxNaLKyfjNmzfh5uaGhg0b4ubNmxAEQeqQiIiIqJgMHz4cW7ZswZYtWzB06NAc94uMTUZkbDKSUuWYuN0Hoijii4YV0L6WLQz1dGBtZgBrs5yTeXXEYSokiV9++QUAMHPmTCbiREREGm7q1KkQBAFLly6FXC7PcT9rMwM4WBlj6bFHSE5TIEUu4tDNYCw99ggOVsYal4gXBJNxKrRHjx7By8sLzs7O+PLLL6UOh4iIiIpZ9erV8dVXX+HJkyc4fPhwrvseuBGMoIg45WOFCARFxOHAjeBijlI9MBmnQluyZAkA4IcffoBMxm8pIiIibfDDDz8AABYvXozcRj2HRidC9tGn5jJBQGh0YrHGpy6YOVGhBAUF4a+//oKDgwP69+8vdThERERUQho1aoR27drBx8cH58+fz3E/e0sjKD5K1hWiCHtLo+IOUS0wGadCWb58OeRyOb7//nvo6elJHQ4RERGVoBkzZgD4UB3PSU83BzjamCofywTA0cYUPd0cij0+dcBuKmpE1bqphIeHw9HREWZmZggKCoKxsbGk8RAREVHJEkURbm5u8PHxwc2bN+Hq6pppO7upsJsKFaNVq1YhKSkJkyZNYiJORESkhQRBwPTp0wFkXx338gnB4A1XMXrrDWU3lQM3gjF66w0M3nAVXj4hJR2yymFlXI2oUmX83bt3qFixIgDgxYsXKFWqlGSxEBERkXTkcjlcXFzg7+8PPz8/VK9eXbktvTKeE1bGWRmnAvrjjz8QExODsWPHMhEnIiLSYjo6Opg2bRpEUcSyZcsybbM2M4CzvXmON01LxAuClXE1oiqV8YSEBDg6OiI2NhZBQUEoW7asJHEQERGRakhOToaTkxPevHmD58+fo1y5clKHJBlWxqnYbdmyBRERERg2bBgTcSIiIoKBgQG+++47pKamYsWKFVKHo1ZYGVcjqlAZT0lJQZUqVfD69Ws8e/ZMOW6ciIiItFtsbCwqVqyIlJQUBAcHo3Tp0lKHJAlWxqlY7dq1CyEhIejXrx8TcSIiIlIyMzPD+PHjER8fj7Vr10odjtpgZVyNSF0ZVygUqFmzJh4/fgxfX1+4uLiU6OsTERGRaouIiEDFihVhbGyMFy9eSL4mihRYGadic/jwYTx+/BgeHh5MxImIiCgLGxsbDB8+HG/fvsWWLVukDkctsDKuRqSsjIuiiEaNGuHWrVu4ceMGGjVqVGKvTUREROrjxYsXqFKlCuzs7BAQEAA9PT2pQypR+c3XdEsiKFJ/Z8+exa1bt9C+fftPJuLa2OCfiIiIPqhYsSL69euH7du3Y/fu3Rg4cKDUIak0VsbViJSVcXd3d1y4cAHnzp1D27Ztc913k/czbLkQkOP2YW2cMMK9SlGHSERERCrC19cXtWrVgouLCx48eACZTHtGRuc3X2MyrkakSsavXr2KZs2aoXHjxrh69SoEQch1//TKeFKqHBO3+0AURXzRsALa17KFoZ4OK+NERERaoHv37jh69CiOHDmCL774QupwSgwncFKR++WXXwAAM2bM+GQiDnwYhuJgZYylxx4hOU2BFLmIQzeDsfTYIzhYGTMRJyIi0gLTp08H8CGPYO03Z0zGKVcPHjzA33//jZo1a6Jbt255Pu7AjWAERcQpHytEICgiDgduBBdHmERERKRimjZtitatW+PatWv4999/pQ5HZXECJ+Vq8eLFAD68u83PeK/Q6ETIBAGKDO+EZYKA0OjEIo+RtIsoikhNTYVCoZA6FCL6BJlMBj09vTx9qkqaafr06bh48SIWL16M1q1bSx2OSmIyTrkaPHgwAKBPnz75Os7e0ihTIg4AClGEvaVRUYVGWkYulyMyMhKxsbFITU2VOhwiyiM9PT2YmZnB2toaOjo6UodDJaxTp06oW7cuTp48ibt376JevXpSh6RyOIGzBMXFxWH58uXw8fGBj48PwsPDMWjQIHh6eubpeKlX4MyPhOQ0DN98HYFvPgxVkQmAo40pNg9vDGMDvgek/JHL5QgJCUFycjIsLCxgamoKHR0dVtuIVJgoipDL5YiLi8P79+9hYGCAChUqMCHXQnv27EHfvn3Ru3dv7NmzR+pwih27qaiwoKAgVKpUCXZ2dmjQoAH++ecfjU3GgQ8JedflFyBXiBjWxgk93RyYiFOBhIeH4927d3BwcICRET9dIVI3iYmJCA4ORqlSpVC2bFmpw6ESlpaWhurVqyMoKAhPnjxBlSqa3d6Yi/6oMDs7O7x8+RLlypVDUlKSxicVxga6MNL/UAEZ2LKyxNGQuhJFEbGxsbCwsND4nxkiTWVkZARzc3PExsaiTJky/FRLy+jq6mLatGkYPXo0li9fjvXr1+f5WG1YSJDJeAkyMDBAuXLlpA6j2GX8wUmTf5hk9zg0RrldE35wqOSkpqYiNTVVWWUgIvVkZmaGd+/eITU1Ffr6+lKHQyVs0KBBmDt3LrZt24a5c+fCzs4uT8d5+YRo/EKCTMapyGX3gzN4w1XlfU34waGSk941heNMidRb+s8wOyFpJ0NDQ0yePBnTp0/HmjVr8NNPP+XpOA/XCmhZvQwAYOL2mwCA3wY2Um7XhOKe2ibjCQkJuHjxIm7duoXbt2/j1q1bCA7+0MN67ty5mDdv3ifPERsbi19//RUHDx7E8+fPoaOjg2rVqqFPnz749ttv+c69gDL+4GRHE35wqOTxY20i9cafYRo5ciQWLlyI9evXY9asWTA2Nv7kMRk/TdfV+dBi2dnevFjjLGlqm4zfuHEDn3/+eYGPf/HiBdq0aYOgoCAAgLGxMZKTk5WdTv766y+cO3cOlpaWWY5NSUnB/fv38/Q6RkZGqFmzZoHjVEcchkJEREQfs7S0xJAhQ7BmzRps374do0ePljoklaDWK3BaWlqiXbt2mDp1Knbv3g1bW9s8HSeXy9GtWzcEBQXBzs4OZ86cQXx8PBISErBnzx6YmZnhzp076N+/f7bHh4aGolGjRnm69e7duyi/ZCIiIiK1NXHiRAiCgJUrV+ZryFJCchoSU+SIS0rD9kuBSEhOK8YoS5baVsZbtmyJqKioTM9Nnz49T8d6enriwYMHAICDBw+iadOmAD6sFNa7d28oFAr069cPJ06cwLlz59CuXbtMx9va2sLb2ztPr6Xq7QeJiIiISkqVKlXQvXt3HD58GCdOnECXLl0+eUz62iUJKXIAwPpz/jh5/7XGrF2itl9BYSZz/fnnnwAAd3d3ZSKeUZ8+fTBr1iw8f/4c27dvz5KMGxoaok2bNgV+fSIiUn3pY5y9vb35O5+oCE2ePBmHDx/GihUr8pSMH7gRjKCIOOVjhQgERcThwI1gjWidrLbJeEElJCTg8uXLAIDOnTtnu48gCPjss8+wbt06nD59uiTDUwna0NOTSNspFAocOXIEf//9N65du4bw8HDExMTA1NQU5cqVQ/369fHZZ5+hW7duMDfXrMlSRCStli1bomHDhjh//jzu3buHunXr5rp/aHQiZIIARYZ1KmWCgNDoxOIOtURoXTLu5+enHKNUq1atHPdL3xYWFoaoqCiULl26SF5/zZo1ePfuHdLSPox1un//PhYtWgQAaNWqFVq1apWn88THx+e4rbBDY7ShpyeRNrt+/ToGDRqEJ0+eKJ/T0dGBhYUF4uPj4evrC19fX+zcuRPm5uaYN28eJk+eLGHE0qhevToA5KnjAxHlnSAImDx5Mr755husXLnykyuR21saZUrEAUAhirC31IyF4LQuGQ8NDVXez20BnozbQkNDiywZX758OV68eKF8fOfOHdy5cwfAh5aMeU3Gc1tOWPzoGza/tKGnJ5G2Onz4MHr37o2UlBRYWVlh0qRJ8PDwgIuLi3JYxps3b3Dp0iXs2LEDf//9N/bu3auVyfjjx4+lDoFIY3399df44YcfsGvXLvzyyy+5LgLU080BJ++/RuCbD0NVZALgaGOKnm4OJRVusdK6ZDw2NlZ5P7dqR8ZtGY8prPRWiqpMG3p6Emmjx48fY8CAAUhJSUGdOnVw4sQJ2NvbZ9mvTJky6NGjB3r06AFfX19s3rxZgmiJSJPp6+vj22+/xfTp0/HHH39g4cKFOe5rbKCLzcMbo+vyC5ArRAxr44Sebg4aMXkTUPPWhtosPDwccXFx2d6IiLLz448/Ii4uDiYmJvDy8so2Ef9YzZo1sXLlykzPpaam4syZM5gwYQJcXV1hZ2cHfX19lClTBp06dcLu3btz/ITO09MTgiDA0dExx9cMCgqCIAgQBCHbAsbjx48xcuRIVKtWDcbGxjAyMkKFChXQpEkTzJw5M9uK9suXLzF58mTUrFkTJiYmMDAwgL29PRo2bIjJkyfj5s2bWY5Jj+HChQtZtj158gTLli1D+/bt4eTkBCMjI5ibm6N+/fr48ccfERkZmePX5+joCEEQ4OnpiZSUFCxbtgx169aFiYkJLCws0LZtW5w8eTLH44k0xciRI2FsbIx169YhMTH38d/GBrow0teBqaEuBrasrDGJOKCFlXEzMzPl/YSEhBz3y7gt4zGqwsTEhG0TiSjPXr9+jUOHDgEABgwYgMqVC96B4PLly+jYsaPysYGBAQwMDBAREYHTp0/j9OnT8PLywp49eyCTFW3N58yZM+jWrRuSkz9MMtfT04OJiQlevnyJly9f4vr169DX18+0CvO9e/fg7u6O6OhoAB/Gx5ubmyMsLAyvX7/G7du3ER0d/clxqxl16tRJOeRQEARYWFjg/fv3uHv3Lu7evQtPT0+cO3dOOe48O3FxcWjVqhWuX78OPT09GBgYICYmBt7e3rhw4QI2b96MoUOH5v8iEamJ9EWA1q5dix07dmDkyJFShyQJrauMZ6wEvXr1Ksf9Mm7LS/VIE2lyg30ibePt7a2sVn/xxReFOpeRkRH69euHf/75B2FhYUhMTERsbCzevn2L3377Debm5ti/fz/WrFlTFKFnMnbsWCQnJ6Njx4548OABUlJSEB0djcTERDx48ADz5s1DxYoVMx0zZcoUREdHo0GDBrh69SpSU1MRFRWFpKQkPH36FMuXL8/3SslNmjTB6tWr8ezZMyQlJSE6OhpJSUk4e/Ys3Nzc8OrVK/Tr1y/Xc8yZMwcvX77E4cOHER8fj9jYWDx+/BhNmjSBKIqYOHEi3r9/n+9rRKROCroIkCbRusp4jRo1IJPJoFAo8PDhwxzbGz58+BDAhwV+imrypjrR9Ab7RNrm0aNHyvv16tUr1LkaN26Mv/76K8vzpUuXxoQJE2Bvb4+vv/4av//+OyZMmFCo18rozZs3ePbsGYAPw10yTvgyNDRErVq1su2SdeXKFQAfulk1adJE+by+vj6qVq2KKVOm5DuWPXv2ZHlOX18f7dq1w7lz51ClShXcvn0b//33H1q0aJHtORISEnDlyhU4Ozsrn6tevTqOHj0KBwcHxMXF4dixYzmuBk2kCapWrYpu3brh6NGjOHXqVJa8LGO75TT5h2T9cWiMcrsmtFvWuqzK2NgYzZs3x6VLl3Dy5ElMnTo1yz6iKOLUqVMAkOmjWG2i6Q32SfPUrVsXb968kTqMIlGmTBncu3evSM/59u1b5f2cCgzPnj3LMXE8dOgQmjVrlqfXSl/EIyAgAK9fv861S0J+mJmZKYsp+TlvqVKlkJiYiNevXxdJHJ9iamqK1q1bY9++fbkm4z179syUiKezsbFB06ZN4e3tjfv37zMZJ403efJkHD16FCtWrMiSjGfXbnnwhqvK+5rQblnrknEAGDRoEC5dugRvb29cv34djRs3zrR9//79CAwMBAAMHDhQihAlp+kN9okoq7S0NISHh2e7LSUlJdPj2NhYrF+/HseOHYOfnx/evXuH1NTULMe9evWqyJJxIyMjtGvXDmfOnMFnn32G0aNHo0uXLqhfvz709fVzPK5r167YtGkTBg0ahMuXL+OLL75Ao0aNCt0//NixY9ixYwdu3ryJ8PDwbOchvXz5MsfjP/7bk1H68MioqKhCxUikDlq3bo369evj7NmzuH//PurUqaPclrHdcnZyq4qryyKGap2MR0dHQy6XKx+njzVKSEjINJPd0NAQpqamyseDBg3Cb7/9hgcPHqBHjx74888/0a5dOygUChw8eBAjRowA8GGFznbt2pXQV5M/2S36U5QTOjW9wT5pnqKuJGsaKysr5f2oqKhsE2RnZ+dMXVCCgoJQqVKlLPs9ffoU7dq1y5RoGhsbo1SpUsoJm+lJfW4LlBXE5s2b8cUXX+DevXtYuHAhFi5cCH19fTRq1Ajdu3fHsGHDslT+ly5dimfPnsHb2xsrVqzAihUroKOjg3r16qFLly4YOXJkrutOfEyhUOCbb77B7t27lc/p6urC0tJS+abg/fv3SEpKyvXrz605gK7uhz/P2b3BIdI0giDgu+++w4ABA7Bq1Sps3bpVua0wCbO6LGKo1hM469evDxsbG+UtJCQEALBs2bJMz48fPz7Tcbq6ujh69CgcHR3x6tUrtG/fXtmdpFevXoiJiUH9+vWzHROpKsqWLQtTU9NMt6LU080Bjjb/O6emNdgn0jYuLi7K+3fv3i3UuYYMGYKXL1/C0dER+/fvx9u3bxEfH483b94gLCws0wT4wi5C9jEHBwfcvn0bJ0+exIQJE9CwYUMoFApcvnwZ06ZNQ5UqVXD+/PlMx5QqVQrnz5/HpUuXMG3aNDRv3hy6urq4desWFixYgKpVq2ZKrD9ly5Yt2L17N3R0dDBnzhz4+/sjOTkZUVFRCAsLQ1hYGHr27FksXz+RpurVqxfs7Ozw119/ISwsrEjO6eFaAZ6jmsJzVFNYGOnCwkhX+dhzVFN4uFYoktcpLLVOxgvD0dER9+/fx5w5c1CrVi0IggA9PT00bNgQy5cvx7Vr12BpaSl1mJJJb7BvrK8DA10ZRrerysmbRGrM3d1ducLm0aNHC3yekJAQ5YTI3bt3o2fPnlkq0bn9IU2v+CYlJeW4z6c6iMhkMnTq1Am//fYbfHx8EBUVhb/++gsODg6Ijo5Gv379sgyrAYAWLVpgyZIl+O+///Du3TscOXIEtWvXRmJiIoYOHZrjEJ2PpU/eHD58OObPn48qVapkaeFYVMkEkbZIXwQoJSUF69atK5JzWpsZwNneHM725tDVkUFXR6Z87GxvrhJDVAA1T8aDgoIgiuInbzn1jjUzM8P8+fPx4MEDxMXFISYmBj4+PpgyZUqu4w9VQXaL/hQ1TW6wT6Rt7Ozs8NVXXwEAduzYgefPnxfoPOmfQAIfPp3MztmzZ3M8Pr3I8ebNG2Wv8I9dv349XzGZmZmhX79+2LJlC4APvx8fPHiQ6zGGhob44osvlL3Xk5KS8N9//+Xp9dKvQU5ff1xcXL6/BiICRo0aBSMjI/zxxx+fXARIk6h1Mq7N0ofVZLwREeVm0aJFMDExQXx8PL788kuEhobm+xwWFhbK+9mN04+NjcWiRYtyPL5u3boAPgzf8PLyyrI9MTExy4qf6bKrdmdkZPS/OS06OjoAPkxKza13cXbHfEr6NchpnsLChQsRGxubp3MR0f+ULl0agwcPRmRkZJEOFVb1dVOYjBMRaQlnZ2fs3LkT+vr6yo4FixYtgq+vb6axzTExMTh58iS+/fbbLOdwcXGBg8OHuSNDhw7FrVu3lNuuXr2KNm3aKFe6zE758uWVrf6+++47nD17VjkR/9atW2jfvn2OLSqvXLmCOnXqYOXKlfDz81Mm2aIo4sqVKxgzZozyNWrXrg3gQzeTqlWrYtGiRbhz5w7S0v73R/j+/fv45ptvAHwocLRq1eoTV/CDzz77DACwadMmbNy4UfkmISwsDJMnT8bSpUszTZglorybOHEiAGDFihVFMuci47opyWkKrD/n/+GxCiXkTMYpi8jYZDwOjcHj0BikyRVIkyuUjx+HxuTaJoiIVNuXX36Jixcvonr16nj79i1mz56NWrVqQU9PD9bW1rCwsICFhQU6d+6MY8eOwczMDAsXLlQuliMIAtauXQtdXV34+vrC1dVV+elcs2bN8PjxY+zduzfXGFavXg0zMzO8fv0aHTp0UE5Cd3V1RUBAAHbs2JHjsQ8ePMB3330HFxcXGBoawtraGvr6+mjevDkePHgAc3Nz7Nq1K1OVOzAwELNnz0aDBg1gaGgIKysrGBgYoG7durhw4QL09fXh6emZ5wXepkyZAmdnZ6SlpSk/Vre0tIS9vT1WrVqFUaNGoWvXrnk6FxFlVr16dXTt2hV+fn7KNV8KI7d1U1QFk3HKwssnBIM3XMXgDVfxPjEN7xPTlI8Hb7gKL5+QT5+EiFRWkyZN8OjRIxw8eBCDBw+Gs7MzzM3N8f79e8hkMtSoUQP9+/fHn3/+idevX+PHH3+EoaGh8viuXbvi33//RZcuXVCqVCmkpaXB2toaQ4YMwe3btz/ZErZevXq4ceMG+vTpgzJlykChUMDa2hrjxo3D3bt3M3V+yahRo0bYt28fxowZg4YNG8La2hrv37+HoaEh6tWrh2nTpsHPzw8tW7ZUHlOuXDkcPXoUkydPRpMmTWBnZ4e4uDjo6urCxcUF48aNw8OHD5XdT/KiVKlSuHLlCiZNmgRHR0fo6OhAV1cXbdq0we7du7F+/fo8n4uIsvruu+8AIMcha/mRvm5KRqq2boogsu+S2oiPj1e2MIyLiyu2ceLq0iSftENSUhKeP3+OSpUqZUoIiUi98GeZ8koURdSvXx/37t3DgwcPUKtWrQKfa/ulQKw/5w9FhmxXJgCj21UtthXF85uvsTJOWWRsBZTdjYk4ERERFZf0RYAAYNWqVYU6lzqsm8JkXE3Fx8dnuRERERFpgj59+sDW1hY7d+7M8xoA2VGHdVOYjKup4l6Bk4iIiEgq+vr6GD9+PJKTkwu9CJCqr5vCZJyIiIiIVM6oUaNgaGiIP/74I9dVe9Udk3E1VRIrcBIRERFJxdraGoMGDUJERESRLgKkapiMqymuwElERESabtKkSQA+tDnMbwNAdVk3RbUGzRARERER/T9nZ2d8/vnnOH78OM6cOYOOHTvm+VgvnxBsuRCQ6bnBG64q7w9r44QR7lWKLNaCYjJORERERCrru+++w/Hjx7Fy5cp8JeMerhXQsnqZHLerSqtmJuNEREREpLLatm2LOnXq4OTJk/D19UXNmjXzdJy6LFLIMeNEREREpLIEQcDkyZMBAL/99pvE0RQ9JuNEREREpNL69u0LGxsb/PXXX4iOjpY6nCLFZJyIiIiIVJqBgQGGDx+OhIQEeHp6Sh1OkWIyrqbi4+Oz3IiIiIg01ejRoyGTyfDHH39AoVBIHU6RYTKupsqWLQtTU9NMNyIiIiJN5eDggO7du+PZs2c4ffq01OEUGXZTISLKRWRscq4LQ6jLbH0iIk0wbtw4eHl5Yc2aNfjss8+kDqdIMBlXU+Hh4Vx1k6gEZLdoREaqsmgEEZE2aNu2LZydnXH8+HEEBgaicuXKUodUaEzG1ZSJiQmTcaISkHHRiInbbwIAfhvYSLmdVXEiopIjCALGjx+P8ePHY926dVi2bJnUIRUax4wTEeXC2swAzvbmcLY3h66ODLo6MuVjZ3tzJuNERCVswIABMDU1xZYtW5CQkCB1OIXGZJyIiIiI1Ia5uTkGDRqE6Oho7NmzR+pwCo3JOBGRFnn79i22bduGb775Bi4uLjAxMYGBgQHKly+PL7/8El5eXjkeO2/ePAiCkOkmk8lgbm6O8uXLo1mzZhg3bhwOHDiAlJSUEvyq1FNsbCzmzZuH2rVrw9TUFBYWFmjUqBF+/fXXIrl+BT1/QkICTpw4gUWLFuGrr75CxYoVlf/f8+bNK3RcREVh7NixAIA1a9ZAFEWJoykcjhknItIitra2SEtLUz42NDSEnp4eXr16hVevXuHIkSPo3LkzDhw4AGNj4xzPU7ZsWeX9xMREhIaG4tWrV7h69Sr++OMPWFlZYeHChRg9ejQEQSjWr0kdvXjxAm3atEFQUBAAwNjYGMnJyfDx8YGPjw/++usvnDt3DpaWliV+/hs3buDzzz8v6JdGVCJcXFzQtm1bnD9/HteuXUPTpk2lDqnAWBknItIiaWlpcHNzwx9//IGAgAAkJiYiLi4Oz58/x7BhwwAAJ06cwKhRo3I9T1hYmPL2/v17pKam4v79+/j1119RqVIlvH37FmPHjsU333yj9lWroiaXy9GtWzcEBQXBzs4OZ86cQXx8PBISErBnzx6YmZnhzp076N+/v2Tnt7S0RLt27TB16lTs3r0btra2Bf1yiYrN+PHjAXyojqs1kdRGXFycCEAEIMbFxUkdDlGJSExMFB89eiQmJiZKHYr4+dLz4udLz0sdRqGcP597/KNGjVL+ngkODs60be7cucptuYmPjxf79Omj3Pfnn38udNyaZPPmzcprc+XKlSzbd+3apdx+9uzZEj9/WlpalucqVqwoAhDnzp2b73jSqdLPMmmG1NRUsUKFCqKenp4YFhYmdThK+c3XWBknItIi7u7uuW5Pr44DgI+PT4Few9jYGH/++Sfq168PAFi8eDGioqIKdK68OnbsGL7++ms4OjrC2Ng4y9j2jLctW7YUayyf8ueffwL48H+R3Ufrffr0QaVKlQAA27dvL/Hz6+jo5Ps1iaSgq6uL0aNHIzU1FZs2bZI6nAJjMq6m4uPjs9yIiArL0NBQeV8ulxf4PPr6+pg5cyYAICYmBocPHy5saNlKTExE9+7d0a1bNxw4cADBwcEwMDCArm7OU6Lq1q1bLLHkRUJCAi5fvgwA6Ny5c7b7CIKgXFkwv0t+F/f5iVTN8OHDoa+vj/Xr12eaD6NOmIyrqbJly8LU1DTTjYiKT0JyGhJT5IhLSsP2S4FISFbPX/qfcuHCBeX92rVrF+pcn332mbLKevHixUKdKyf9+vXD0aNHoaOjg9mzZyMsLAzR0dGIjY3FypUrlfs1btwY27Ztw7Zt2wr9dRWGn58fFAoFAKBWrVo57pe+LSwsLF+fKhT3+YlUTZkyZdCrVy/lBHR1xGSciOgTEpLTMHzzdSSkyJGcpsD6c/4fHmtYQv7u3Tv88ssvAICWLVuievXqhTqfqampcqnqgICAQsf3sR07digr7hs2bMCCBQtQpsyH1VINDQ0xadIk9O7dGwDw7NkzDB48GIMHD4aBQfYLNXl6euY6vOVTt4xvZHISGhqqvF+uXLkc98u4LeMxUp+fSBWp+0ROtjZUU+Hh4TAxMZE6DCKtcOBGMIIi4pSPFSIQFBGHAzeCMbBlZQkjKzoKhQIDBgzA69evYWBggNWrVxfJeUuXLg0ARV59FUURixYtAgB8+eWXmca6Z9StWzfs3bsXb9++xevXr2FnZ5fjOY2MjDK1bMwvfX39T+4TGxurvJ9b68iM2zIeI/X5iVSRm5sbGjZsiAsXLsDX1xc1a9aUOqR8YTKupkxMTJiME5WQ0OhEyAQBigwt+mSCgNDo/2vv/oOiuO//gT+X4zg4fogCgmjNEWKMFnQsxq8/QozVEoiaHyohxkaN+VjDlGlo1diOP8hkjGmVYOoPxiQ6GNtYNYnxZyM1kVATJanG0aANaDxFsWoQEbg7FI739w9yGwgccOcte3c8HzM3c9y+97Xv3dcu+2J5365FxV651ksvvYR9+/YBAHJzc102rloodFvDo0ePorS0FACwYMECu+3CwsLk9/X19e3GTEtLk6+kE5HnkCQJGRkZeP7557F+/Xrk5uaq3SWHcJgKEVEHonsGtCjEAaBRCET3DFCpR661YMEC+d+7q1evxpw5c1wW++bNmwBaFsWu8OmnnwJoeohRew/7uH79OgDAx8fHLe6VHRwcLL83m8122zWf1nweteMTuau0tDSEhYVhy5YtuHXrltrdcQiLcSKiDkwb0R+GiB+/JO0jAYaIIEwb0V/FXrnGyy+/jDfeeAMAsGrVKmRmZrosdm1tLc6fPw8AiI2NdVlcAPjmm28ANP172sfH/qnM9sXRIUOGdGoYidKio6Pl9+Xl5XbbNZ/WfB614xO5q4CAALzwwgswmUxO3RJUTSzGiYg6oNf5YuP//T/o/TTQ+frgxfEDmn7WefZIv4ULF2LVqlUAgJUrV7Y73MMZBw4ckG+P+Mgjj7g0tq2YDA8Pt9vGarViz549ANCpx7tv374dUVFRTr+OHDnS4TIGDRok//FQXFxst51tWlRUlDzuvjOUjk/kztLT0yFJEtavX+9RT/5lMU5E1Al6nS8C/DQI8vfFzMR7Pb4QX7BgAbKzswE0FeILFy50afw7d+5gxYoVAIAePXrgySefdGl8233Eb9y4YbfNW2+9hYqKCmg0GsydO7fDmBaLBdeuXXP6defOnQ6XodfrMWbMGABNf6y0RQiB/Px8AEBSUlKHMbsyPpE7MxgMmDx5MkpKSuShbJ6AxTgRUTezYMECeWhKdna2ywtxi8WC2bNn48SJEwCAP/3pTwgNDXXpMh544AEAQEFBAaqqqlpN//bbb/Hyyy8DAH73u9/BYDB0GHP27NkQQjj96uzV/1mzZsl9//LLL1tNf//99+XhPTNnzuxUzK6MT+TOfvvb3wLwrNscshgnIupGFi1aJBfiOTk5mD9/vkviNjY2ori4GDk5Ofj5z3+Of/zjHwCA5557Ti6Kf+rChQvyPbpfeeUVh5Y3Y8YMAE1P90xNTUVZWRkAoK6uDn/729+QmJgIk8mEMWPG4LXXXnN+xRQwa9YsxMfHQwiBqVOnylfwGhsb8f7778tX8VNSUjB+/PhW8ze/H3pb9za/2/hA0xdvKyoq5JftQUJms7nF57W1tW3OT6SWCRMm4P7778fevXtx8eJFtbvTOYI8Rm1trQAgAIja2lq1u0PUJSwWizhz5oywWCxqd0U8tvKQeGzlIbW74bSLFy/Kv0N8fHxEZGRku69Vq1a1mD8rK0uev3m70NBQ4ePjI08DIMLDw8WGDRva7Y/RaJTbZ2VlObw+GRkZLZYZGhoqfH195Z+feuopcevWLYfjdgWj0SgMBoPcV71eL/z9/eWfhw0bJiorK9ucNy8vT25XUFDg8vhCCHHPPfe02Lb2XrNmzer0OrvTsUze7c033xQAxB//+EdVlu9ovcYr40RE3YTt6qbtfUdjoNu76mlrc/36dTQ0NCAqKgojR45Eeno6PvjgA5SXl2PevHnt9qf5HT1Gjhzp8PqsXbsW7733HsaOHYvQ0FCYzWZERUXh6aefRn5+Pnbu3ImQkBCH43YFg8GAU6dOYdmyZYiLi4MkSdBqtUhISEB2djaKiorQs2dPt41P5M5mzZqFwMBAvPPOO6irq1O7Ox2ShPCgr5t2cyaTCUFBTbdXq62t5UN/qFuoq6uD0WhETEwM/P39Ve3LxFUFAID9C8ep2g9vsXz5cixduhQPPfQQDh8+rHZ3SGHudCyT90tPT8eGDRuwefNm+XsUXcXReo1XxomISBWHDh0CAPmuK0RErmL7Iuf69etV7knHPPveXN2YyWRq9RmvlBO5XkXNbVTU3AYANFibhnl8e6Vanh4erEN4sE6Vvnmy27dv4+jRo0hOTkZiYqLa3SEiLxMXF4exY8eisLAQX331FUaMGKF2l+xiMe6hIiMjW33GEUdErvfRsUvY9Nl3LT6b/dZR+f0Lj8Ri7rj7urpbHk+n08FisajdDSLyYhkZGSgsLMT69evduhjnmHEP0nwMUluYSvJGao8zbX5lvC28Mk7UOWofy9T91NfXw2AwoKKiApcvX0ZERESXLJdjxrsJ250Omr+IyPXCg3V4IDrE7ouFOBGRe9JqtXjxxRdx584dbNy4Ue3u2MVi3EMFBga2ehERERHRj+bOnQutVosNGzagoaFB7e60icU4EREREXmlqKgoTJs2DWVlZdi3b5/a3WkTi3EiIiIi8loZGRkA3Pc2hyzGiYiIiMhrjRo1CiNGjEDv3r1RX1+vdnda4a0Nicgj8G5BRJ6NxzCpRZIkfPHFF/D1dc+yl1fGicit+fg0/ZqyWq0q94SI7obtGLYd00RdyV0LcYDFOBG5Oa1WC61Wy9t3Enm4mpoa+Xgmoh+xGCcityZJEoKDg3Hr1i0+sZHIQ1ksFlRXVyM4OBiSJKndHSK34r7X7ImIfhAeHg6LxYKysjKEhIQgODgYGo2GJ3UiNyaEgNVqRU1NDaqrq6HT6RAeHq52t4jcDotxInJ7Go0GP/vZz1BRUYGamhpUVVWp3SUi6iStVovQ0FCEh4dDo9Go3R0it8NinIg8gkajQWRkpHxrqsbGRrW7REQd8PHxgVar5X+xiNrBYpyIPIokSfDz81O7G0RERC7BL3ASEREREamExThRJ5hMJkiSBEmSYDKZ1O5Ot8ZcuBfmw30wF+6DuXAfnpALFuNERERERCrhmHEP1dZfd4GBgSr0hIiIiIicxWLcQ0VGRrb6TAihQk+IiIiIyFkcpkJEREREpBJeGfdQ165d47AUIiIiIg/HYtyDdDQMxV2/JewNmm9bbmd1MRfuhflwH8yF+2Au3IcauWi+nM4MIZYEBxp7jOvXr7c5VpyIiIiI3M+1a9fQu3fvdttwzDgRERERkUp4ZdyDNDY2oqKiAgCg1+shSZLKPSIiIiKi5oQQMJvNAIDw8HD4+LR/7ZvFOBERERGRSjhMhYiIiIhIJSzGiYiIiIhUwmKciIiIiEglLMaJiIiIiFTCYpyIiIiISCUsxomIiIiIVMJinIiIiIhIJSzGidpQU1ODV155BfHx8QgKCkKPHj3w4IMP4o033sCdO3ecjlteXo7c3FykpqbivvvuQ0BAAAICAhATE4Pp06fj0KFDLlwL76FUPqqqqrB7924sW7YMkyZNQp8+fSBJEiRJwubNm123Ah5AqW0MND0Oev78+Rg4cCACAgLQq1cvJCYmYuPGjeCjLtqmRD64vztHiVzwXOAcJXJRWFiIxYsX49FHH8WAAQPQs2dPaLVa9O7dG+PGjcOaNWtgsVhcvCY/IYiohQsXLgiDwSAACABCr9cLnU4n/zxs2DBRWVnpcNyysjIhSZIcxxY7ICCgxWdz5swRDQ0NCqyZZ1IqH0IIkZeX12LbN3/l5eW5dkXcmJLb+NixYyIsLEyOFRQUJHx9feWfk5KSRF1dnYvXyLMplQ/u745TIhc8FzhHqeNi4sSJLbZ7YGCgCAwMbPFZTEyMKCkpUWCtmrAYJ2qmoaFBxMfHCwCiT58+4uDBg0IIIaxWq9i2bZsIDg4WAERKSorDsY1GowAgxo8fL959911RXl4uxz59+rR44okn5AN/yZIlLl0vT6VkPoRoKk6ioqJESkqKWLx4sfjwww+7XXGi5DauqqoSUVFRAoB44IEHxH/+8x8hhBC3b98W69atE1qtVgAQ6enpLl0nT6ZkPri/O0apXPBc4Dglj4vVq1eLNWvWiK+//lpUV1fLn1dUVIg1a9bIfyQNHjxYWK1Wl61TcyzGiZrZuHGj/EvwyJEjraZv3bpVnv7JJ584FLuqqkocP37c7vTGxkaRnJwsXz20WCwO99/bKJkPIYSor69v9Vl3K06U3MZLliwRAERAQIA4f/58q+krVqwQAIRGo1H0qpMnUTIf3N8do1QueC5wnNLngva89dZbcuzPP//cpbFtWIwTNZOYmCgAiHHjxrU5vbGxUcTExAgAYubMmS5f/o4dO+SD/uuvv3Z5fE+jRj66W3Gi5Dbu37+/ACCef/75NqfX1NSIoKAgAUAsW7bM4b57o67e57vb/u4INc8HPBe0pGYuTp48Kedi27ZtLo1twy9wEv3AbDbjiy++AACkpKS02UaSJCQnJwMA/vWvf7m8D/7+/vJ7q9Xq8viexB3y4e2U3MYlJSUoKytrN3ZQUBASExMdju2tuM+7D7VzwXPBj9TOxeHDh+X3sbGxLo1tw2Kc6Af//e9/0djYCACIi4uz28427erVq6isrHRpHz777DMAgJ+fH+6//36XxvY07pAPb6fkNi4uLm41f3uxz5w506m43oz7vPtQOxc8F/xIjVxYLBacPXsWK1aswPz58wEADz/8MIYPH35Xce3xVSQqkQe6cuWK/L5v37522zWfduXKFfTq1cslyzcajdiwYQMAIC0tDSEhIS6J66nUzkd3oOQ2djR2dXU1amtrERQU1GFsb8V93n2omQueC1rqqlxcvXoVffr0aXPa5MmTFb39J6+ME/2gpqZGfq/X6+22az6t+Tx3w2KxIDU1FWazGWFhYXj99dddEteTqZmP7kLJbcz8OY7bzH2olQueC1rrqlxoNBpERkYiMjKyxTCh1NRUrFy5UtE/elmMk0fbvHmz/NAKZ14HDhxQexXQ0NCAZ599FsePH4dWq8XWrVvb/evfnXlDPoiI1OBN5wJPFBERgatXr+Lq1aswm824dOkSFi9ejL1792LIkCF4++23FVs2i3GiHwQHB8vvzWaz3XbNpzWfxxlWqxW//vWvsWvXLvj6+mLr1q1ISkq6q5jeQo18dDdKbmPmz3HcZu6jq3PBc4F9ahwXkiShX79+WL58Od577z3U19cjPT0dJ0+evKu49nDMOHm06dOnY9KkSU7P36NHD/l9dHS0/L68vBxDhgxpc57y8vI253GU7Zfv9u3bodFo8Pe//x3Tpk1zOp478OR8dEdKbuOfxrY37tUWOyQkpFuPFwe4z7uTrsyFN54LXEnt42LKlCm45557cPHiRWzatAlr1qxxWWwbFuPk0XQ6HXQ6nUtiDRo0CD4+PmhsbERxcbHdWyjZ7hIRFRXl9Bgyq9WKGTNmtPjlm5aW5nTf3YWn5qO7UnIbN7/rQXFxMQYNGtRu7MGDBzvSda/Efd59dFUuvPVc4ErucFxER0fj4sWLOHfunEvj2nCYCtEP9Ho9xowZAwB2xy4LIZCfnw8ATv8Lsa1fvs8884xznfZiXZWP7kzJbTxw4ED079+/3dgmk0m+hy/zx33enXRFLngu6By1jwshBIxGIwAFh4Up8ighIg9le+SuJEmiqKio1fTt27ff1SN3GxoaxNNPPy0ACF9fX8We5uUtlM5HW9DNnkio5DZesmSJACD0er0wGo2tpv/lL38RAIRGoxElJSXOroJX6ep9vrvt745QMhc8FzhGqVzU19d32GbTpk1y7NzcXIf63Vksxomaqa+vF/Hx8QKA6Nu3r3xQW61WsWPHDhESEiIAiJSUlDbnz8rKkg/anxYfDQ0NYvr06fIv3x07dii9Oh5PyXzYfP/99y1etvZr165t8bnJZFJqNVV1N9u4o+1bVVUloqKiBAAxePBgcezYMSGEELdv3xa5ubnCz89PABDp6emKrqMnUTIfQnB/d4RSueC5wHFK5aKgoEAkJiaKLVu2iEuXLrWYVlpaKhYtWiR8fX0FABEbGyvMZrMi68dinOgnjEajMBgM8sGr1+uFv7+//POwYcNEZWVlm/O2d9AXFhbK07RarYiMjGz3xSslTZTKh41tekevrKws5VZSZc5u485s32PHjomwsDC5XXBwsNBqtfLPSUlJoq6uTuE19CxK5oP7u2OUyAXPBc5RIhcFBQUt9nt/f38RHh4uAgICWnw+dOhQu8eUK3DMONFPGAwGnDp1CsuWLUNcXBwkSYJWq0VCQgKys7NRVFSEnj17OhzX9jhfAKivr8e1a9fafVksFleulsdSKh/0IyW3cUJCAk6fPo3f//73GDBgAOrr6xEYGIiHHnoI77zzDj7++GOXfenXW3Cfdx9K5ILnAucokYuEhARs2bIFc+bMwdChQ9GjRw9UVVXBx8cHsbGxSE1NxbZt23D8+HEYDAZlVgyAJIQQikUnIiIiIiK7eGWciIiIiEglLMaJiIiIiFTCYpyIiIiISCUsxomIiIiIVMJinIiIiIhIJSzGiYiIiIhUwmKciIiIiEglLMaJiIiIiFTCYpyIiIiISCUsxomIyON9/vnnSEhIQFBQEKZOnQqz2ax2l4iIOkUSQgi1O0FEROSsEydOYPTo0airq5M/W7lyJRYuXKhir4iIOodXxomI6K7973//Q1ZWFkaPHo2IiAhotVrodDr07dsXEydOxAcffKDYsjMzM/Hcc8/hk08+QWhoKACgurpaseUREbkSr4wTEdFdOXLkCB577DHcunULAODn54eQkBDcvn0bNTU1AIBf/OIXOH78eKfiZWdnw9/fHxkZGR22vXDhAiZMmICSkhJoNBocPXoUH3/8MTIzM9GrVy/nV4qIqIuwGCciorsycOBAlJaW4pe//CXefPNNxMXFQZIkAEBtbS2KiopgNBoxd+7cTsWbMmUKSktLUVxc3GHbnJwcVFVV4dVXX72rdSAiUguLcSIiclp5eTn69esHANizZw8mT5581zFjY2Nx/vx5HDlyBKNGjWq3bWJiInJycvDggw/e9XKJiNTAMeNEROS0iIgIhIeHAwBmzpyJRYsW4dChQzCZTE7Fq66uhtFoBABs3Lix3bbff/89jEYjhg8f7tSyiIjcAYtxIiJymp+fH/bs2YOgoCAEBwdj3759SE5ORmhoKB555BHs3r3boXinTp2C7R+227Ztk8eht2XPnj1ISUmRh8QQEXkiFuNEROS07777Di+99BKeeeYZnD17FqdPn0ZNTQ02b96MkydP4sknn8Qf/vCHTsc7ceIEQkJCAABmsxnvvvuu3ba7d+92ybAYIiI1ccw4ERE55dy5c0hMTMTo0aPx4Ycftpp+8OBBJCUlAQA+++wzjB07tsOYM2fOhMFgQG5uLm7cuIH77rsPpaWlra5+m81m9OvXD5cvX4Zer3fNChERqYBXxomIyGF1dXV46qmncPPmTaxdu7bNNr/61a8QExMDAPjoo486FbeoqAgPP/wwZs+eDaCp4N+/f3+rdgcPHsSoUaNYiBORx2MxTkREDlu3bh2Ki4vx+OOPIzo62m673r17A2j6smVHKioqYDQaMXLkSMybN0++Gp6Tk9Oq7d69ezlEhYi8AotxIiJy2Ntvvw0A8jAUe2xFeGcewHP48GEMHz4cQUFBGDBgAKZMmQIAKCgowJdffim3a2xsxP79+zFp0iRnu09E5DZYjBMRkUOuXLmCs2fPAgDi4+PbbWe7TeGgQYM6jJufn9+iuF+6dKl8dXzRokXy51999RX69Okj39+ciMiTsRgnIiKHnD9/Xn4fFhZmt92uXbvk2xQ++uij7ca0Wq3YvXt3i6vdQ4cOxRNPPAEAKCwsxM6dOwHwLipE5F1YjBMRkUOsVqv8vqKios02JpMJq1evBgCMHz8esbGx7cb89NNPERgY2OpJmn/+85+h1WoBAJmZmaitrcXevXs5RIWIvAaLcSIickjzwnrXrl1ttsnMzMS5c+eg0Wjw+uuvdxgzLy8P8+bNa/X5wIEDkZGRAQC4dOkSUlNTcePGDT51k4i8BotxIiJySL9+/TBmzBgATXc6ycvLQ0NDA4CmWxGmpaXJj7LPzs5udbW7oKAAy5cvR21tLQDgm2++wT//+U/MmTOnzeVlZWXJd2U5cOAAJk2axKduEpHX4EN/iIjIYWfOnEFiYiIqKysBADqdDv7+/vLj6wMCAvDXv/4Vc+fObTVvREQEKioqkJqait/85jd48cUX8eyzz+LVV1+1u7ydO3di6tSpAJrGjD/++OMKrBURUddjMU5ERE65fPkyXnvtNeTn5+PKlSvw8/NDbGwskpOTkZGRgb59+7Y537333ivfZQUAJkyYgP3798PPz6/d5c2YMQM7d+7EjRs3+LAfIvIaLMaJiKhL/fvf/8YLL7yA69evY8aMGVi9ejV0Ol2H8928eRPr1q3D0qVLu6CXRERdg8U4EREREZFK+AVOIiIiIiKVsBgnIiIiIlIJi3EiIiIiIpWwGCciIiIiUgmLcSIiIiIilbAYJyIiIiJSCYtxIiIiIiKVsBgnIiIiIlIJi3EiIiIiIpWwGCciIiIiUgmLcSIiIiIilbAYJyIiIiJSCYtxIiIiIiKV/H9uymYL9L6nIAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7, label=\"2D, $\\sigma=$\"+str(sigma),\n", + " color=color[0])\n", + "plt.plot(bin_centres, gaussian_pdf(bin_centres), color=\"k\",\n", + " label=\"Gaussian\")\n", + "plt.yscale('log')\n", + "plt.legend(fontsize=18)\n", + "plt.xlabel(r'$\\delta \\mathcal{N}$')\n", + "plt.ylabel(r'$P(\\delta \\mathcal{N})$')\n", + "plt.title(r\"Gaussian bump, $\\delta \\phi_{\\mathrm{h}}$\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The non-Gassuianity becomes very clear here!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1D noise\n", + "Now let's investigate the effect of using a 2D noise. This is the same as the 2D case but the Cython code is changed." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " Cython: _cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.pyx\n", + " \n", + "\n", + "\n", + "

Generated by Cython 3.0.7

\n", + "

\n", + " Yellow lines hint at Python interaction.
\n", + " Click on a line that starts with a \"+\" to see the C code that Cython generated for it.\n", + "

\n", + "
 001:
\n", + "
+002: import numpy as np
\n", + "
  __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 003:
\n", + "
+004: cdef double V_0 = 7.903587107979402e-11
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V_0 = 7.903587107979402e-11;\n",
+       "
+005: cdef double e = 2.718281828459045
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_e = 2.718281828459045;\n",
+       "
+006: cdef double pi_num = 3.141592653589793
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_pi_num = 3.141592653589793;\n",
+       "
+007: cdef double sigma_tilde = 1.59*(10**-2)
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde = (1.59 * pow(10.0, -2.0));\n",
+       "
+008: cdef double phi_0 = 2.18812
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_phi_0 = 2.18812;\n",
+       "
+009: cdef double m_squared = 0.25
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_m_squared = 0.25;\n",
+       "
+010: cdef double K = 1.17*(10**-3)
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_K = (1.17 * pow(10.0, -3.0));\n",
+       "
+011: cdef double diff_const_squared = 6.351213422073874e-13
\n", + "
  __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_diff_const_squared = 6.351213422073874e-13;\n",
+       "
 012: cdef double phi_end
\n", + "
 013: cdef double expo
\n", + "
 014: cdef double fraction
\n", + "
 015: cdef double fraction3
\n", + "
 016: cdef double fraction4
\n", + "
 017: cdef double noise_value
\n", + "
 018: cdef double bias_value
\n", + "
 019: cdef double term1
\n", + "
 020: cdef double term2
\n", + "
 021: cdef double phi_old
\n", + "
 022:
\n", + "
 023:
\n", + "
+024: cdef double V(double phi):
\n", + "
static double __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V(double __pyx_v_phi) {\n",
+       "  __pyx_t_double_complex __pyx_v_expo;\n",
+       "  double __pyx_v_fraction;\n",
+       "  double __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.V\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = -1;\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+025:     expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)
\n", + "
  __pyx_t_1 = (__pyx_v_phi - __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_phi_0);\n",
+       "  if (unlikely(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 25, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_expo = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_e, 0), __pyx_t_double_complex_from_parts((-0.5 * pow((__pyx_t_1 / __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde), 2.0)), 0));\n",
+       "
+026:     fraction = (phi**2)/(m_squared + phi**2)
\n", + "
  __pyx_t_1 = pow(__pyx_v_phi, 2.0);\n",
+       "  __pyx_t_2 = (__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_m_squared + pow(__pyx_v_phi, 2.0));\n",
+       "  if (unlikely(__pyx_t_2 == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 26, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_fraction = (__pyx_t_1 / __pyx_t_2);\n",
+       "
+027:     return V_0*fraction*(1 + K*expo)
\n", + "
  __pyx_t_2 = __Pyx_SoftComplexToDouble(__Pyx_c_prod_double(__pyx_t_double_complex_from_parts((__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V_0 * __pyx_v_fraction), 0), __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(1, 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_K, 0), __pyx_v_expo))), 1); if (unlikely(__pyx_t_2 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 27, __pyx_L1_error)\n",
+       "  __pyx_r = __pyx_t_2;\n",
+       "  goto __pyx_L0;\n",
+       "
 028:
\n", + "
+029: cdef double V_prime_by_V_cython(double phi):
\n", + "
static double __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V_prime_by_V_cython(double __pyx_v_phi) {\n",
+       "  __pyx_t_double_complex __pyx_v_expo;\n",
+       "  double __pyx_v_fraction3;\n",
+       "  double __pyx_v_fraction4;\n",
+       "  double __pyx_v_term1;\n",
+       "  __pyx_t_double_complex __pyx_v_term2;\n",
+       "  double __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.V_prime_by_V_cython\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = -1;\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+030:     expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)
\n", + "
  __pyx_t_1 = (__pyx_v_phi - __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_phi_0);\n",
+       "  if (unlikely(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 30, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_expo = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_e, 0), __pyx_t_double_complex_from_parts((-0.5 * pow((__pyx_t_1 / __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde), 2.0)), 0));\n",
+       "
+031:     fraction3 = 1/phi - (phi)/(m_squared + phi**2)
\n", + "
  if (unlikely(__pyx_v_phi == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 31, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_1 = (__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_m_squared + pow(__pyx_v_phi, 2.0));\n",
+       "  if (unlikely(__pyx_t_1 == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 31, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_fraction3 = ((1.0 / __pyx_v_phi) - (__pyx_v_phi / __pyx_t_1));\n",
+       "
+032:     fraction4 = -(phi-phi_0)/(sigma_tilde**2)
\n", + "
  __pyx_t_1 = (-(__pyx_v_phi - __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_phi_0));\n",
+       "  __pyx_t_2 = pow(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_sigma_tilde, 2.0);\n",
+       "  if (unlikely(__pyx_t_2 == 0)) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 32, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_fraction4 = (__pyx_t_1 / __pyx_t_2);\n",
+       "
 033:
\n", + "
+034:     term1 = 2*fraction3
\n", + "
  __pyx_v_term1 = (2.0 * __pyx_v_fraction3);\n",
+       "
+035:     term2 = fraction4*K*expo/(1 + K*expo)
\n", + "
  __pyx_t_3 = __Pyx_c_prod_double(__pyx_t_double_complex_from_parts((__pyx_v_fraction4 * __pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_K), 0), __pyx_v_expo);\n",
+       "  __pyx_t_4 = __Pyx_c_sum_double(__pyx_t_double_complex_from_parts(1, 0), __Pyx_c_prod_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_K, 0), __pyx_v_expo));\n",
+       "  if (unlikely(__Pyx_c_is_zero_double(__pyx_t_4))) {\n",
+       "    PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "    __PYX_ERR(0, 35, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_term2 = __Pyx_c_quot_double(__pyx_t_3, __pyx_t_4);\n",
+       "
+036:     return term1 + term2
\n", + "
  __pyx_t_2 = __Pyx_SoftComplexToDouble(__Pyx_c_sum_double(__pyx_t_double_complex_from_parts(__pyx_v_term1, 0), __pyx_v_term2), 1); if (unlikely(__pyx_t_2 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L1_error)\n",
+       "  __pyx_r = __pyx_t_2;\n",
+       "  goto __pyx_L0;\n",
+       "
 037:
\n", + "
+038: cdef int end_cond(double phi, double pi, double N, double phi_end):
\n", + "
static int __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_end_cond(double __pyx_v_phi, CYTHON_UNUSED double __pyx_v_pi, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_phi_end) {\n",
+       "  int __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+039:     if phi<phi_end:
\n", + "
  __pyx_t_1 = (__pyx_v_phi < __pyx_v_phi_end);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+040:         return 1
\n", + "
    __pyx_r = 1;\n",
+       "    goto __pyx_L0;\n",
+       "
 041:     else:
\n", + "
+042:         return 0
\n", + "
  /*else*/ {\n",
+       "    __pyx_r = 0;\n",
+       "    goto __pyx_L0;\n",
+       "  }\n",
+       "
 043:
\n", + "
 044:
\n", + "
+045: cdef list update(double phi, double pi, double A, double N, double dN, double [:] dW, double [:] noise,
\n", + "
static PyObject *__pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_update(double __pyx_v_phi, double __pyx_v_pi, double __pyx_v_A, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_dN, __Pyx_memviewslice __pyx_v_dW, __Pyx_memviewslice __pyx_v_noise, double __pyx_v_bias_amp) {\n",
+       "  double __pyx_v_phi_old;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_7);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_XDECREF(__pyx_t_9);\n",
+       "  __Pyx_XDECREF(__pyx_t_10);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.update\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 046:                  double bias_amp):
\n", + "
 047:     # Store old phi value to be used in calculating velocity
\n", + "
+048:     phi_old = phi
\n", + "
  __pyx_v_phi_old = __pyx_v_phi;\n",
+       "
 049:
\n", + "
 050:     # Update field position
\n", + "
+051:     phi = phi + (pi + bias_amp*noise[0])*dN + noise[0]*dW[0]
\n", + "
  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 51, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 51, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_4 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 51, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_phi = ((__pyx_v_phi + ((__pyx_v_pi + (__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_1 * __pyx_v_noise.strides[0]) ))))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_4 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 052:
\n", + "
 053:     # Update the velocity
\n", + "
 054:     pi =\\
\n", + "
+055:         pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN + bias_amp*noise[1]*dN + noise[1]*dW[0]
\n", + "
  __pyx_t_5 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_V_prime_by_V_cython(__pyx_v_phi_old); if (unlikely(__pyx_t_5 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  __pyx_t_4 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_3 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 55, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_pi = (((__pyx_v_pi - (((3.0 - (0.5 * pow(__pyx_v_pi, 2.0))) * (__pyx_v_pi + __pyx_t_5)) * __pyx_v_dN)) + ((__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_4 * __pyx_v_noise.strides[0]) )))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 056:
\n", + "
+057:     if noise[0]>0:
\n", + "
  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 57, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_6 = ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_1 * __pyx_v_noise.strides[0]) ))) > 0.0);\n",
+       "  if (__pyx_t_6) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
 058:         # Calculate the weight. This is the same as the true 1d case with diffusion based bias
\n", + "
+059:         A += bias_amp*(0.5*bias_amp*dN + dW[0])
\n", + "
    __pyx_t_1 = 0;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_1 < 0) {\n",
+       "      __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 59, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_v_A = (__pyx_v_A + (__pyx_v_bias_amp * (((0.5 * __pyx_v_bias_amp) * __pyx_v_dN) + (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) ))))));\n",
+       "
 060:
\n", + "
+061:     return [phi, pi, A]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_phi); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 61, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_pi); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 61, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_8);\n",
+       "  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_A); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 61, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_9);\n",
+       "  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 61, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_10);\n",
+       "  __Pyx_GIVEREF(__pyx_t_7);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_t_7)) __PYX_ERR(0, 61, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_8);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_8)) __PYX_ERR(0, 61, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_9);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_t_9)) __PYX_ERR(0, 61, __pyx_L1_error);\n",
+       "  __pyx_t_7 = 0;\n",
+       "  __pyx_t_8 = 0;\n",
+       "  __pyx_t_9 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_10);\n",
+       "  __pyx_t_10 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 062:
\n", + "
 063:
\n", + "
 064: #A let's us calculate the bias w=e^-A is the bias, which propagated along with
\n", + "
 065: #the importance sample path.
\n", + "
 066: #See Eq. (33) of arXiv:nucl-th/9809075v1 for more info
\n", + "
+067: cdef list simulation_diff_general_end(double x_in, double y_in, double t_in, double t_f, double dt,
\n", + "
static PyObject *__pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_simulation_diff_general_end(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, PyObject *__pyx_v_rng) {\n",
+       "  double __pyx_v_t;\n",
+       "  double __pyx_v_sqrt_dt;\n",
+       "  double __pyx_v_x;\n",
+       "  double __pyx_v_y;\n",
+       "  double __pyx_v_A;\n",
+       "  int __pyx_v_i;\n",
+       "  int __pyx_v_end_cond_value;\n",
+       "  int __pyx_v_len_rand_nums;\n",
+       "  int __pyx_v_reduced_step;\n",
+       "  int __pyx_v_num_steps;\n",
+       "  __Pyx_memviewslice __pyx_v_rand_nums = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_dW = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_noise = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_4);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.simulation_diff_general_end\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_dW, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_noise, 1);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 068:                                       double bias_amp, double phi_end_in, noise_list, rng):
\n", + "
 069:     cdef double t, sqrt_dt, x, y, z, A
\n", + "
+070:     cdef int i = 0
\n", + "
  __pyx_v_i = 0;\n",
+       "
 071:     cdef int end_cond_value
\n", + "
+072:     cdef int len_rand_nums = 1000
\n", + "
  __pyx_v_len_rand_nums = 0x3E8;\n",
+       "
+073:     cdef int reduced_step = 0
\n", + "
  __pyx_v_reduced_step = 0;\n",
+       "
+074:     cdef int num_steps = 0
\n", + "
  __pyx_v_num_steps = 0;\n",
+       "
 075:
\n", + "
 076:     cdef double [:, :] rand_nums
\n", + "
 077:     cdef double [:] dW
\n", + "
 078:     cdef double [:] noise
\n", + "
 079:
\n", + "
+080:     t = t_in
\n", + "
  __pyx_v_t = __pyx_v_t_in;\n",
+       "
+081:     x = x_in
\n", + "
  __pyx_v_x = __pyx_v_x_in;\n",
+       "
+082:     y = y_in
\n", + "
  __pyx_v_y = __pyx_v_y_in;\n",
+       "
+083:     sqrt_dt = dt**0.5
\n", + "
  __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+084:     A = 0.0
\n", + "
  __pyx_v_A = 0.0;\n",
+       "
+085:     rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_INCREF(__pyx_int_2);\n",
+       "  __Pyx_GIVEREF(__pyx_int_2);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_2)) __PYX_ERR(0, 85, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error);\n",
+       "  __pyx_t_3 = 0;\n",
+       "  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_4) < 0) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__9, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_rand_nums = __pyx_t_5;\n",
+       "  __pyx_t_5.memview = NULL;\n",
+       "  __pyx_t_5.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__9 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__9);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__9);\n",
+       "
+086:     dW = rand_nums[:, 0]
\n", + "
  __pyx_t_6.data = __pyx_v_rand_nums.data;\n",
+       "  __pyx_t_6.memview = __pyx_v_rand_nums.memview;\n",
+       "  __PYX_INC_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __pyx_t_6.shape[0] = __pyx_v_rand_nums.shape[0];\n",
+       "__pyx_t_6.strides[0] = __pyx_v_rand_nums.strides[0];\n",
+       "    __pyx_t_6.suboffsets[0] = -1;\n",
+       "\n",
+       "{\n",
+       "    Py_ssize_t __pyx_tmp_idx = 0;\n",
+       "        Py_ssize_t __pyx_tmp_shape = __pyx_v_rand_nums.shape[1];\n",
+       "    Py_ssize_t __pyx_tmp_stride = __pyx_v_rand_nums.strides[1];\n",
+       "        if (__pyx_tmp_idx < 0)\n",
+       "            __pyx_tmp_idx += __pyx_tmp_shape;\n",
+       "        if (unlikely(!__Pyx_is_valid_index(__pyx_tmp_idx, __pyx_tmp_shape))) {\n",
+       "            PyErr_SetString(PyExc_IndexError,\n",
+       "                            \"Index out of bounds (axis 1)\");\n",
+       "            __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "        }\n",
+       "        __pyx_t_6.data += __pyx_tmp_idx * __pyx_tmp_stride;\n",
+       "}\n",
+       "\n",
+       "__pyx_v_dW = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "
+087:     noise = noise_list[:, 0]
\n", + "
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_tuple__10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 87, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_noise = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_slice__5, __pyx_int_0); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 87, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__10);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__10);\n",
+       "
 088:
\n", + "
+089:     while t<t_f:
\n", + "
  while (1) {\n",
+       "    __pyx_t_7 = (__pyx_v_t < __pyx_v_t_f);\n",
+       "    if (!__pyx_t_7) break;\n",
+       "
 090:         # Scale the step varaince to the dt used
\n", + "
+091:         dW[0] = sqrt_dt*rand_nums[0, i]
\n", + "
    __pyx_t_8 = 0;\n",
+       "    __pyx_t_9 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 91, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 91, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_8 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_9 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
+092:         dW[1] = sqrt_dt*rand_nums[1, i]
\n", + "
    __pyx_t_9 = 1;\n",
+       "    __pyx_t_8 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 92, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 92, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_9 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_8 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
 093:         # Find the noise from the list provided
\n", + "
+094:         noise[0] = noise_list[0, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_0);\n",
+       "    __Pyx_GIVEREF(__pyx_int_0);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_0)) __PYX_ERR(0, 94, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 94, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
+095:         noise[1] = noise_list[1, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_1);\n",
+       "    __Pyx_GIVEREF(__pyx_int_1);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_1)) __PYX_ERR(0, 95, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 95, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
 096:         # Define the Wiener step, using the pre-drawn random numbers.
\n", + "
 097:         # Step in x and A simultanioues
\n", + "
+098:         [x, y, A] =\\
\n", + "
    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_13 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "    __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    __pyx_v_x = __pyx_t_12;\n",
+       "    __pyx_v_y = __pyx_t_13;\n",
+       "    __pyx_v_A = __pyx_t_14;\n",
+       "
+099:             update(x, y, A, t, dt, dW, noise, bias_amp)
\n", + "
    __pyx_t_4 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_update(__pyx_v_x, __pyx_v_y, __pyx_v_A, __pyx_v_t, __pyx_v_dt, __pyx_v_dW, __pyx_v_noise, __pyx_v_bias_amp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    if (likely(__pyx_t_4 != Py_None)) {\n",
+       "      PyObject* sequence = __pyx_t_4;\n",
+       "      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "      if (unlikely(size != 3)) {\n",
+       "        if (size > 3) __Pyx_RaiseTooManyValuesError(3);\n",
+       "        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "        __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "      }\n",
+       "      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); \n",
+       "      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); \n",
+       "      __Pyx_INCREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_1);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      #else\n",
+       "      __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      #endif\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    } else {\n",
+       "      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 98, __pyx_L1_error)\n",
+       "    }\n",
+       "
+100:         t += dt
\n", + "
    __pyx_v_t = (__pyx_v_t + __pyx_v_dt);\n",
+       "
+101:         i += 1
\n", + "
    __pyx_v_i = (__pyx_v_i + 1);\n",
+       "
+102:         num_steps += 1
\n", + "
    __pyx_v_num_steps = (__pyx_v_num_steps + 1);\n",
+       "
 103:         # Using 1/0 for True/False
\n", + "
+104:         end_cond_value = end_cond(x, y, t, phi_end_in)
\n", + "
    __pyx_t_10 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_end_cond(__pyx_v_x, __pyx_v_y, __pyx_v_t, __pyx_v_phi_end_in); if (unlikely(__pyx_t_10 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error)\n",
+       "    __pyx_v_end_cond_value = __pyx_t_10;\n",
+       "
+105:         if end_cond_value == 1:
\n", + "
    __pyx_t_7 = (__pyx_v_end_cond_value == 1);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "
+106:             break
\n", + "
      goto __pyx_L4_break;\n",
+       "
+107:         elif end_cond_value == -1 and reduced_step == 0:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == -1L);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L6_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 0);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L6_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "      goto __pyx_L5;\n",
+       "    }\n",
+       "
+108:             dt = dt/100
\n", + "
      __pyx_v_dt = (__pyx_v_dt / 100.0);\n",
+       "
+109:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+110:             reduced_step = 1
\n", + "
      __pyx_v_reduced_step = 1;\n",
+       "
+111:         elif end_cond_value == 0 and reduced_step == 1:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == 0);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L8_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 1);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L8_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "    __pyx_L5:;\n",
+       "
+112:             dt = 100*dt
\n", + "
      __pyx_v_dt = (100.0 * __pyx_v_dt);\n",
+       "
+113:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+114:             reduced_step = 0
\n", + "
      __pyx_v_reduced_step = 0;\n",
+       "
 115:         # If all of the random numbers have been used up, need to update them.
\n", + "
 116:         # This should still be more efficient than drawing a new random number
\n", + "
 117:         # each time.
\n", + "
+118:         if i == len_rand_nums:
\n", + "
    __pyx_t_7 = (__pyx_v_i == __pyx_v_len_rand_nums);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "  }\n",
+       "  __pyx_L4_break:;\n",
+       "
+119:             rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_4);\n",
+       "      __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_int_2);\n",
+       "      __Pyx_GIVEREF(__pyx_int_2);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_2)) __PYX_ERR(0, 119, __pyx_L1_error);\n",
+       "      __Pyx_GIVEREF(__pyx_t_1);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 119, __pyx_L1_error);\n",
+       "      __pyx_t_1 = 0;\n",
+       "      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_size, __pyx_t_2) < 0) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__9, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "      __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 119, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "      __pyx_v_rand_nums = __pyx_t_5;\n",
+       "      __pyx_t_5.memview = NULL;\n",
+       "      __pyx_t_5.data = NULL;\n",
+       "
+120:             i = 0
\n", + "
      __pyx_v_i = 0;\n",
+       "
+121:     return [t, e**(-A)]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_16 = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_e, 0), __pyx_t_double_complex_from_parts((-__pyx_v_A), 0));\n",
+       "  __pyx_t_3 = __pyx_Py_FromSoftComplex(__pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_GIVEREF(__pyx_t_2);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error);\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_4);\n",
+       "  __pyx_t_4 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 122:
\n", + "
 123:
\n", + "
+124: cpdef importance_sampling_simulations_2d_1d_noise(double x_in, double y_in, double t_in, double t_f,
\n", + "
static PyObject *__pyx_pw_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyObject *__pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_importance_sampling_simulations_2d_1d_noise(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, CYTHON_UNUSED int __pyx_skip_dispatch) {\n",
+       "  PyObject *__pyx_v_rng = NULL;\n",
+       "  PyObject *__pyx_v_results = NULL;\n",
+       "  PyObject *__pyx_v_ts = NULL;\n",
+       "  PyObject *__pyx_v_ws = NULL;\n",
+       "  CYTHON_UNUSED int __pyx_7genexpr__pyx_v_i;\n",
+       "  long __pyx_8genexpr1__pyx_v_j;\n",
+       "  int __pyx_8genexpr2__pyx_v_i;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.importance_sampling_simulations_2d_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XDECREF(__pyx_v_rng);\n",
+       "  __Pyx_XDECREF(__pyx_v_results);\n",
+       "  __Pyx_XDECREF(__pyx_v_ts);\n",
+       "  __Pyx_XDECREF(__pyx_v_ws);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "/* Python wrapper */\n",
+       "static PyObject *__pyx_pw_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyMethodDef __pyx_mdef_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise = {\"importance_sampling_simulations_2d_1d_noise\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
+       "static PyObject *__pyx_pw_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       ") {\n",
+       "  double __pyx_v_x_in;\n",
+       "  double __pyx_v_y_in;\n",
+       "  double __pyx_v_t_in;\n",
+       "  double __pyx_v_t_f;\n",
+       "  double __pyx_v_dt;\n",
+       "  int __pyx_v_num_runs;\n",
+       "  double __pyx_v_bias_amp;\n",
+       "  double __pyx_v_phi_end_in;\n",
+       "  PyObject *__pyx_v_noise_list = 0;\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  CYTHON_UNUSED Py_ssize_t __pyx_nargs;\n",
+       "  #endif\n",
+       "  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;\n",
+       "  PyObject *__pyx_r = 0;\n",
+       "  __Pyx_RefNannyDeclarations\n",
+       "  __Pyx_RefNannySetupContext(\"importance_sampling_simulations_2d_1d_noise (wrapper)\", 0);\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  #if CYTHON_ASSUME_SAFE_MACROS\n",
+       "  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);\n",
+       "  #else\n",
+       "  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;\n",
+       "  #endif\n",
+       "  #endif\n",
+       "  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);\n",
+       "  {\n",
+       "    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_in,&__pyx_n_s_y_in,&__pyx_n_s_t_in,&__pyx_n_s_t_f,&__pyx_n_s_dt,&__pyx_n_s_num_runs,&__pyx_n_s_bias_amp,&__pyx_n_s_phi_end_in,&__pyx_n_s_noise_list,0};\n",
+       "  PyObject* values[9] = {0,0,0,0,0,0,0,0,0};\n",
+       "    if (__pyx_kwds) {\n",
+       "      Py_ssize_t kw_args;\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  0: break;\n",
+       "        default: goto __pyx_L5_argtuple_error;\n",
+       "      }\n",
+       "      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  0:\n",
+       "        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_x_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else goto __pyx_L5_argtuple_error;\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1:\n",
+       "        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_y_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 1); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2:\n",
+       "        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 2); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3:\n",
+       "        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_f)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 3); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4:\n",
+       "        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dt)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 4); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5:\n",
+       "        if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_num_runs)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[5]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 5); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6:\n",
+       "        if (likely((values[6] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bias_amp)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[6]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 6); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7:\n",
+       "        if (likely((values[7] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_phi_end_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[7]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 7); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8:\n",
+       "        if (likely((values[8] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_noise_list)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[8]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, 8); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "        }\n",
+       "      }\n",
+       "      if (unlikely(kw_args > 0)) {\n",
+       "        const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
+       "        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"importance_sampling_simulations_2d_1d_noise\") < 0)) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "      }\n",
+       "    } else if (unlikely(__pyx_nargs != 9)) {\n",
+       "      goto __pyx_L5_argtuple_error;\n",
+       "    } else {\n",
+       "      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "      values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "      values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "      values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "      values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "    }\n",
+       "    __pyx_v_x_in = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "    __pyx_v_y_in = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_y_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "    __pyx_v_t_in = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_t_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "    __pyx_v_t_f = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_t_f == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "    __pyx_v_dt = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_dt == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 125, __pyx_L3_error)\n",
+       "    __pyx_v_num_runs = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_num_runs == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 125, __pyx_L3_error)\n",
+       "    __pyx_v_bias_amp = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_bias_amp == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 125, __pyx_L3_error)\n",
+       "    __pyx_v_phi_end_in = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_phi_end_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 125, __pyx_L3_error)\n",
+       "    __pyx_v_noise_list = values[8];\n",
+       "  }\n",
+       "  goto __pyx_L6_skip;\n",
+       "  __pyx_L5_argtuple_error:;\n",
+       "  __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2d_1d_noise\", 1, 9, 9, __pyx_nargs); __PYX_ERR(0, 124, __pyx_L3_error)\n",
+       "  __pyx_L6_skip:;\n",
+       "  goto __pyx_L4_argument_unpacking_done;\n",
+       "  __pyx_L3_error:;\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.importance_sampling_simulations_2d_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return NULL;\n",
+       "  __pyx_L4_argument_unpacking_done:;\n",
+       "  __pyx_r = __pyx_pf_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_importance_sampling_simulations_2d_1d_noise(__pyx_self, __pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list);\n",
+       "  int __pyx_lineno = 0;\n",
+       "  const char *__pyx_filename = NULL;\n",
+       "  int __pyx_clineno = 0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "static PyObject *__pyx_pf_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_importance_sampling_simulations_2d_1d_noise(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list) {\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_importance_sampling_simulations_2d_1d_noise(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 124, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d.importance_sampling_simulations_2d_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = NULL;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "/* … */\n",
+       "  __pyx_tuple__22 = PyTuple_Pack(9, __pyx_n_s_x_in, __pyx_n_s_y_in, __pyx_n_s_t_in, __pyx_n_s_t_f, __pyx_n_s_dt, __pyx_n_s_num_runs, __pyx_n_s_bias_amp, __pyx_n_s_phi_end_in, __pyx_n_s_noise_list); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 124, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__22);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__22);\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_1importance_sampling_simulations_2d_1d_noise, 0, __pyx_n_s_importance_sampling_simulations, NULL, __pyx_n_s_cython_magic_29b43f5a1a5ff71efd, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 124, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_importance_sampling_simulations, __pyx_t_7) < 0) __PYX_ERR(0, 124, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 125:                                                 double dt, int num_runs, double bias_amp, double phi_end_in,
\n", + "
 126:                                                 noise_list):
\n", + "
 127:     # As this variable is global, I can just redfine it hear
\n", + "
+128:     rng = np.random.default_rng()
\n", + "
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 128, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_default_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "  __pyx_t_3 = NULL;\n",
+       "  __pyx_t_4 = 0;\n",
+       "  #if CYTHON_UNPACK_METHODS\n",
+       "  if (likely(PyMethod_Check(__pyx_t_2))) {\n",
+       "    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);\n",
+       "    if (likely(__pyx_t_3)) {\n",
+       "      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      __Pyx_INCREF(function);\n",
+       "      __Pyx_DECREF_SET(__pyx_t_2, function);\n",
+       "      __pyx_t_4 = 1;\n",
+       "    }\n",
+       "  }\n",
+       "  #endif\n",
+       "  {\n",
+       "    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};\n",
+       "    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);\n",
+       "    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  }\n",
+       "  __pyx_v_rng = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "
 129:     results =\\
\n", + "
+130:         [simulation_diff_general_end(x_in, y_in, t_in, t_f, dt, bias_amp, phi_end_in, noise_list, rng)
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "/* … */\n",
+       "      __pyx_t_2 = __pyx_f_54_cython_magic_29b43f5a1a5ff71efdfd0feb317c267eaae2123d_simulation_diff_general_end(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, __pyx_v_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 130, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  __pyx_v_results = ((PyObject*)__pyx_t_1);\n",
+       "  __pyx_t_1 = 0;\n",
+       "
+131:          for i in range(num_runs)]
\n", + "
    __pyx_t_4 = __pyx_v_num_runs;\n",
+       "    __pyx_t_5 = __pyx_t_4;\n",
+       "    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "      __pyx_7genexpr__pyx_v_i = __pyx_t_6;\n",
+       "
 132:
\n", + "
+133:     ts, ws = [[results[i][j] for i in range(num_runs)] for j in range(2)]
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    for (__pyx_t_7 = 0; __pyx_t_7 < 2; __pyx_t_7+=1) {\n",
+       "      __pyx_8genexpr1__pyx_v_j = __pyx_t_7;\n",
+       "      { /* enter inner scope */\n",
+       "        __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "        __Pyx_GOTREF(__pyx_t_2);\n",
+       "        __pyx_t_4 = __pyx_v_num_runs;\n",
+       "        __pyx_t_5 = __pyx_t_4;\n",
+       "        for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "          __pyx_8genexpr2__pyx_v_i = __pyx_t_6;\n",
+       "          __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_results, __pyx_8genexpr2__pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_3);\n",
+       "          __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, __pyx_8genexpr1__pyx_v_j, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_8);\n",
+       "          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "          if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;\n",
+       "        }\n",
+       "      } /* exit inner scope */\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  if (1) {\n",
+       "    PyObject* sequence = __pyx_t_1;\n",
+       "    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "    if (unlikely(size != 2)) {\n",
+       "      if (size > 2) __Pyx_RaiseTooManyValuesError(2);\n",
+       "      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "      __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "    }\n",
+       "    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "    __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "    __pyx_t_8 = PyList_GET_ITEM(sequence, 1); \n",
+       "    __Pyx_INCREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_t_8);\n",
+       "    #else\n",
+       "    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 133, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_8);\n",
+       "    #endif\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  }\n",
+       "  __pyx_v_ts = __pyx_t_2;\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_v_ws = __pyx_t_8;\n",
+       "  __pyx_t_8 = 0;\n",
+       "
+134:     return ts, ws
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __Pyx_INCREF(__pyx_v_ts);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ts);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_ts)) __PYX_ERR(0, 134, __pyx_L1_error);\n",
+       "  __Pyx_INCREF(__pyx_v_ws);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ws);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ws)) __PYX_ERR(0, 134, __pyx_L1_error);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%cython -a\n", + "\n", + "import numpy as np\n", + "\n", + "cdef double V_0 = 7.903587107979402e-11\n", + "cdef double e = 2.718281828459045\n", + "cdef double pi_num = 3.141592653589793\n", + "cdef double sigma_tilde = 1.59*(10**-2)\n", + "cdef double phi_0 = 2.18812\n", + "cdef double m_squared = 0.25\n", + "cdef double K = 1.17*(10**-3)\n", + "cdef double diff_const_squared = 6.351213422073874e-13\n", + "cdef double phi_end\n", + "cdef double expo\n", + "cdef double fraction\n", + "cdef double fraction3\n", + "cdef double fraction4\n", + "cdef double noise_value\n", + "cdef double bias_value\n", + "cdef double term1\n", + "cdef double term2\n", + "cdef double phi_old\n", + "\n", + "\n", + "cdef double V(double phi):\n", + " expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction = (phi**2)/(m_squared + phi**2)\n", + " return V_0*fraction*(1 + K*expo)\n", + "\n", + "cdef double V_prime_by_V_cython(double phi):\n", + " expo = e**(-0.5*((phi-phi_0)/sigma_tilde)**2)\n", + " fraction3 = 1/phi - (phi)/(m_squared + phi**2)\n", + " fraction4 = -(phi-phi_0)/(sigma_tilde**2)\n", + " \n", + " term1 = 2*fraction3\n", + " term2 = fraction4*K*expo/(1 + K*expo)\n", + " return term1 + term2\n", + " \n", + "cdef int end_cond(double phi, double pi, double N, double phi_end):\n", + " if phi0:\n", + " # Calculate the weight. This is the same as the true 1d case with diffusion based bias\n", + " A += bias_amp*(0.5*bias_amp*dN + dW[0])\n", + "\n", + " return [phi, pi, A]\n", + "\n", + "\n", + "#A let's us calculate the bias w=e^-A is the bias, which propagated along with \n", + "#the importance sample path.\n", + "#See Eq. (33) of arXiv:nucl-th/9809075v1 for more info\n", + "cdef list simulation_diff_general_end(double x_in, double y_in, double t_in, double t_f, double dt,\n", + " double bias_amp, double phi_end_in, noise_list, rng):\n", + " cdef double t, sqrt_dt, x, y, z, A\n", + " cdef int i = 0\n", + " cdef int end_cond_value\n", + " cdef int len_rand_nums = 1000\n", + " cdef int reduced_step = 0\n", + " cdef int num_steps = 0\n", + " \n", + " cdef double [:, :] rand_nums\n", + " cdef double [:] dW\n", + " cdef double [:] noise\n", + "\n", + " t = t_in\n", + " x = x_in\n", + " y = y_in\n", + " sqrt_dt = dt**0.5\n", + " A = 0.0\n", + " rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))\n", + " dW = rand_nums[:, 0]\n", + " noise = noise_list[:, 0]\n", + "\n", + " while t" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.errorbar(bin_centres_2D, heights_2D, yerr=errors_2D, fmt=\".\", ms=7, label=\"2D, $\\sigma=$\"+str(sigma),\n", + " color=color[0])\n", + "plt.plot(bin_centres_2D, gaussian_pdf(bin_centres_2D), color=\"k\",\n", + " label=\"Gaussian\")\n", + "\n", + "# Now let's process and plot the 1D data\n", + "for j in range(len(sigma_values)):\n", + " sigma = sigma_values[j]\n", + " raw_data = pd.read_csv(\"IS_data_x_in_2.2_iterations_100000_bias_0.0_Gaussian_bump_sigma_\"+str(sigma)+\n", + " \"_scale_exited31.13832_1D_noise_bessel.csv\", index_col=0)\n", + "\n", + " # Easier to work with NumPy arrays\n", + " Ns = np.array(raw_data['FPTs'])\n", + "\n", + " bin_centres, heights, errors = fpt.numerics.re_processing(Ns, estimator=\"naive\", min_bin_size=100)\n", + " # Apply the delta N formula\n", + " bin_centres = np.array(bin_centres) - find_cg_time(k_end_scale_later, sigma, N_sim_end_later)\n", + "\n", + " plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7, label=\"1D, $\\sigma=$\"+str(sigma),\n", + " color=color[j+1])\n", + " \n", + "plt.yscale('log')\n", + "plt.legend(fontsize=18)\n", + "plt.xlabel(r'$\\delta \\mathcal{N}$')\n", + "plt.ylabel(r'$P(\\delta \\mathcal{N})$')\n", + "plt.title(r\"Gaussian bump, $\\delta \\phi_{\\mathrm{h}}$\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clearly all of the data sets are consistent!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/User guides/Advanced/Gaussian_bump/README.md b/User guides/Advanced/Gaussian_bump/README.md new file mode 100644 index 0000000..5256d5a --- /dev/null +++ b/User guides/Advanced/Gaussian_bump/README.md @@ -0,0 +1 @@ +In this folder we apply importance sampling to the [Gaussian bump model](https://arxiv.org/abs/1911.00057). diff --git a/User guides/Advanced/Gaussian_bump/mystyle.py b/User guides/Advanced/Gaussian_bump/mystyle.py new file mode 100644 index 0000000..305571d --- /dev/null +++ b/User guides/Advanced/Gaussian_bump/mystyle.py @@ -0,0 +1,66 @@ +# flake8: noqa + +from cycler import cycler +# box style +paper_style = { + # Colour cycle + 'axes.prop_cycle': cycler(color=['#377eb8', '#ff7f00', '#984ea3', + '#4daf4a', '#a65628', '#f781bf', + '#999999', '#e41a1c', '#dede00']), + + # Line styles + 'lines.linewidth': 1.3, + 'lines.antialiased': True, + + # Error bars + 'errorbar.capsize': 3, # length of end cap on error bars in pixels + + # Font + 'font.size': 18.0, + + # Axes + 'axes.linewidth': 1.5, + 'axes.titlesize': 'x-large', + 'axes.labelsize': 'large', + 'axes.spines.top': True, + 'axes.spines.right': True, + + # Ticks + 'xtick.major.size': 6, + 'xtick.minor.size': 4, + 'xtick.major.width': 1.5, + 'xtick.minor.width': 1.5, + 'xtick.major.pad': 6, + 'xtick.minor.pad': 6, + 'xtick.labelsize': 'medium', + 'xtick.direction': 'in', + 'xtick.top': False, + + 'ytick.major.size': 6, + 'ytick.minor.size': 4, + 'ytick.major.width': 1.5, + 'ytick.minor.width': 1.5, + 'ytick.major.pad': 6, + 'ytick.minor.pad': 6, + 'ytick.labelsize': 'medium', + 'ytick.direction': 'in', + 'ytick.right': False, + + # Legend + 'legend.fancybox': True, + 'legend.fontsize': 'large', + 'legend.scatterpoints': 5, + 'legend.loc': 'best', + + # Figure + 'figure.figsize': [8, 5.2], + 'figure.titlesize': 'large', + + # Images + 'image.cmap': 'magma', + 'image.origin': 'lower', + + # Saving + 'savefig.bbox': 'tight', + 'savefig.format': 'png', +} diff --git a/User guides/Advanced/Piece_wise/Piece-wise linear 3 - direct simulations.ipynb b/User guides/Advanced/Piece_wise/Piece-wise linear 3 - direct simulations.ipynb new file mode 100644 index 0000000..85606b9 --- /dev/null +++ b/User guides/Advanced/Piece_wise/Piece-wise linear 3 - direct simulations.ipynb @@ -0,0 +1,4291 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Piece-wise linear potential 3 - direct simulations\n", + "\n", + "This is the third in a series of notebooks which will run importance sampling for the Gaussian bump potential. Familiarity with stochastic simulations is assumed.\n", + "\n", + "In this notebook we show how to run stochastic simulations and compare the different noise models.\n", + "\n", + "We start as we did before by defining everything we need and loading in the required data\n", + "\n", + "Throughout natural units with $c = 8\\pi M_{\\rm PL} = \\hbar =1$ are used." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import mystyle\n", + "plt.style.use(mystyle.paper_style)\n", + "\n", + "# Need to make sure you have pyfpt installed\n", + "import pyfpt as fpt\n", + "import multiprocessing as mp\n", + "from multiprocessing import Process, Queue\n", + "from timeit import default_timer as timer\n", + "\n", + "from scipy.optimize import root\n", + "from scipy.integrate import quad\n", + "from scipy.integrate import trapezoid\n", + "from scipy.interpolate import CubicSpline\n", + "\n", + "# Let us define the different colours used\n", + "color = ['#377eb8', '#ff7f00', '#984ea3','#4daf4a', '#a65628', '#f781bf','#999999', '#e41a1c', '#dede00']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The potential" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def potential(phi):\n", + " if phi > phi_star:\n", + " return V_0 + A_plus*(phi - phi_star)\n", + " elif phi <= phi_star:\n", + " return V_0 + A_minus*(phi - phi_star)\n", + "\n", + " \n", + "def potential_dif(phi):\n", + " if phi > phi_star:\n", + " return A_plus\n", + " elif phi <= phi_star:\n", + " return A_minus\n", + "\n", + "def potential_ddif(phi):\n", + " return 0.\n", + "\n", + "def V_prime_by_V(phi):\n", + " if phi > phi_star:\n", + " return A_plus/(V_0 + A_plus*(phi - phi_star))\n", + " elif phi <= phi_star:\n", + " return A_minus/(V_0 + A_minus*(phi - phi_star))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are shown such that the power spectrum peaks at $5 \\times 10^{-3}$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "pi_num = np.pi\n", + "\n", + "A_plus = 10**-14\n", + "A_minus = A_plus*(10**-3)\n", + "cmb_power_spectrum = 2*10**-9\n", + "V_0 = (12*cmb_power_spectrum*(pi_num*A_plus)**2)**(1/3)\n", + "H_0 = (V_0/3)**(1/2)\n", + "N_star = 26.\n", + "phi_star = 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading in background\n", + "We have already simulated the background, now we can just load it in." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "background_data = pd.read_csv(\"piece_wise_linear_dynamics_dynamics\"+\".csv\", index_col=0)\n", + "\n", + "N_values = np.array(background_data[\"N\"])\n", + "phi_values = np.array(background_data[\"phi\"])\n", + "phi_diff_values = np.array(background_data[\"phi_N_diff\"])\n", + "hubble_param_values = np.array(background_data[\"H\"])\n", + "epsilon1_values = np.array(background_data[\"epsilon1\"])\n", + "epsilon2_values = np.array(background_data[\"epsilon2\"])\n", + "nu_squared_values = np.array(background_data[\"nu_squared\"])\n", + "\n", + "N_end = N_values[-1]\n", + "phi_end_true = phi_values[-1]\n", + "a_in = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "hubble_param_interpolation = CubicSpline(N_values, hubble_param_values)\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_star))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Updating the interpolation which are senstive to any errors to use the analytical versions." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def comoving_time_func(N_interest, N_end):\n", + " def comoving_time_integrand(N):\n", + " aH = aH_interpolation(N)\n", + " return 1/aH\n", + " comoving_time_value, _ = quad(comoving_time_integrand, N_end, N_interest, limit=1000)\n", + " return comoving_time_value\n", + "\n", + "def analytical_epsilon_1(N_interest, N_end, N_transition, A_plus, A_minus):\n", + " H = hubble_param_interpolation(N_interest)\n", + " if N_interest<=N_transition:\n", + " epsilon_1 = (A_plus**2)/(18*(H**4))\n", + " elif N_interest>N_transition:\n", + " Delta_A = A_minus - A_plus\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_transition = aH_interpolation(N_transition)\n", + " epsilon_1 = ((Delta_A*(comoving_time*k_transition)**3 + A_minus)**2)/(18*(H**4))\n", + " return epsilon_1\n", + "\n", + "def analytical_epsilon_2(N_interest, N_end, N_transition, A_plus, A_minus):\n", + " H = hubble_param_interpolation(N_interest)\n", + " if N_interest<=N_transition:\n", + " epsilon_2 = 0.\n", + " elif N_interest>N_transition:\n", + " Delta_A = A_minus - A_plus\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_transition = aH_interpolation(N_transition)\n", + " epsilon_2 =\\\n", + " (-6*Delta_A*(comoving_time*k_transition)**3)/(Delta_A*(comoving_time*k_transition)**3 + A_minus)\n", + " return epsilon_2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "epsilon1_values = np.array([analytical_epsilon_1(N_values[i], N_end, N_star, A_plus, A_minus) for i in range(len(N_values))])\n", + "epsilon2_values = np.array([analytical_epsilon_2(N_values[i], N_end, N_star, A_plus, A_minus) for i in range(len(N_values))])\n", + "\n", + "# interpolation\n", + "epsilon1_interpolation = CubicSpline(N_values, epsilon1_values)\n", + "epsilon2_interpolation = CubicSpline(N_values, epsilon2_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def nu_sqaured_func(N):\n", + " epsilon2 = epsilon2_interpolation(N, 0)\n", + " epsilon1 = epsilon1_interpolation(N, 0)\n", + " epsilon2_derivative = epsilon2_interpolation(N, 1)\n", + " return 9/4 - epsilon1 + (3/2)*epsilon2 - (1/2)*epsilon1*epsilon2 + (epsilon2**2)/4\\\n", + " + epsilon2_derivative/2" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "nu_squared_values = np.array([nu_sqaured_func(N_values[i]) for i in range(len(N_values))])\n", + "\n", + "nu_squared_interpolation = CubicSpline(N_values, nu_squared_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_star))\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_star))\n", + "\n", + "N_sim_end_estimate = N_star + np.log(10**3)\n", + "\n", + "sim_range_logic = (N_values>N_star+0.05) & (N_valuesN_transition:\n", + " alpha = 1. + complex(0, 1)*(3*Delta_A*k_0/(2*A_plus*k))*(1 + (k_0/k)**2)\n", + " beta = complex(0, -1)*(3*Delta_A*k_0/(2*A_plus*k))*np.exp(complex(0, 2*k/k_0))*(complex(1, k_0/k)**2)\n", + " else:\n", + " alpha = 1.\n", + " beta = 0.\n", + "\n", + " term1 = complex(1, k_eta)*np.exp(complex(0, -k_eta))\n", + " term2 = complex(1, -k_eta)*np.exp(complex(0, k_eta))\n", + " k_term = complex(0, H0/(2*k**3)**0.5)\n", + "\n", + " delta_phi = k_term*(alpha*term1 - beta*term2)\n", + " return delta_phi" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def power_spectrum_func(k, R):\n", + " return (np.abs(R)**2)*(k**3)/(2*np.pi**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Direct simulations\n", + "## 2D noise\n", + "We will first investigate a 2D noise model. The simulations are run using Cython compiled locally for efficiency." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext cython" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " Cython: _cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1.pyx\n", + " \n", + "\n", + "\n", + "

Generated by Cython 3.0.7

\n", + "

\n", + " Yellow lines hint at Python interaction.
\n", + " Click on a line that starts with a \"+\" to see the C code that Cython generated for it.\n", + "

\n", + "
 001:
\n", + "
+002: import numpy as np
\n", + "
  __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 003:
\n", + "
+004: cdef double e = 2.718281828459045
\n", + "
  __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_e = 2.718281828459045;\n",
+       "
+005: cdef double pi_const = 3.141592653589793
\n", + "
  __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_pi_const = 3.141592653589793;\n",
+       "
+006: cdef double phi_star = 1.0
\n", + "
  __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_phi_star = 1.0;\n",
+       "
+007: cdef double A_plus = 1e-14
\n", + "
  __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_A_plus = 1e-14;\n",
+       "
+008: cdef double A_minus = 1e-17
\n", + "
  __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_A_minus = 1e-17;\n",
+       "
+009: cdef double V_0 = 2.871906714642027e-12
\n", + "
  __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_V_0 = 2.871906714642027e-12;\n",
+       "
+010: cdef double diff_const = 1.5572025557368665e-07
\n", + "
  __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_diff_const = 1.5572025557368665e-07;\n",
+       "
 011: cdef double phi_old
\n", + "
 012:
\n", + "
 013:
\n", + "
+014: cdef double V_prime_by_V_cython(double phi):
\n", + "
static double __pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_V_prime_by_V_cython(double __pyx_v_phi) {\n",
+       "  double __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_r = 0;\n",
+       "  goto __pyx_L0;\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1.V_prime_by_V_cython\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = -1;\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+015:     if phi > phi_star:
\n", + "
  __pyx_t_1 = (__pyx_v_phi > __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_phi_star);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+016:         return A_plus/(V_0 + A_plus*(phi - phi_star))
\n", + "
    __pyx_t_2 = (__pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_V_0 + (__pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_A_plus * (__pyx_v_phi - __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_phi_star)));\n",
+       "    if (unlikely(__pyx_t_2 == 0)) {\n",
+       "      PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "      __PYX_ERR(0, 16, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_r = (__pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_A_plus / __pyx_t_2);\n",
+       "    goto __pyx_L0;\n",
+       "
+017:     elif phi <= phi_star:
\n", + "
  __pyx_t_1 = (__pyx_v_phi <= __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_phi_star);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+018:         return A_minus/(V_0 + A_minus*(phi - phi_star))
\n", + "
    __pyx_t_2 = (__pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_V_0 + (__pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_A_minus * (__pyx_v_phi - __pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_phi_star)));\n",
+       "    if (unlikely(__pyx_t_2 == 0)) {\n",
+       "      PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "      __PYX_ERR(0, 18, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_r = (__pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_A_minus / __pyx_t_2);\n",
+       "    goto __pyx_L0;\n",
+       "
 019:
\n", + "
+020: cdef int end_cond(double phi, double pi, double N, double phi_end):
\n", + "
static int __pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_end_cond(double __pyx_v_phi, CYTHON_UNUSED double __pyx_v_pi, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_phi_end) {\n",
+       "  int __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+021:     if phi<phi_end:
\n", + "
  __pyx_t_1 = (__pyx_v_phi < __pyx_v_phi_end);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+022:         return 1
\n", + "
    __pyx_r = 1;\n",
+       "    goto __pyx_L0;\n",
+       "
 023:     else:
\n", + "
+024:         return 0
\n", + "
  /*else*/ {\n",
+       "    __pyx_r = 0;\n",
+       "    goto __pyx_L0;\n",
+       "  }\n",
+       "
 025:
\n", + "
 026:
\n", + "
+027: cdef list update(double phi, double pi, double A, double N, double dN, double [:] dW, double [:] noise,
\n", + "
static PyObject *__pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_update(double __pyx_v_phi, double __pyx_v_pi, double __pyx_v_A, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_dN, __Pyx_memviewslice __pyx_v_dW, __Pyx_memviewslice __pyx_v_noise, double __pyx_v_bias_amp) {\n",
+       "  double __pyx_v_phi_old;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_9);\n",
+       "  __Pyx_XDECREF(__pyx_t_10);\n",
+       "  __Pyx_XDECREF(__pyx_t_11);\n",
+       "  __Pyx_XDECREF(__pyx_t_12);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1.update\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 028:                  double bias_amp):
\n", + "
 029:     # Store old phi value to be used in calculating velocity
\n", + "
+030:     phi_old = phi
\n", + "
  __pyx_v_phi_old = __pyx_v_phi;\n",
+       "
 031:     # Update field position
\n", + "
 032:     # If noise is zero, no bias is automatically applied
\n", + "
+033:     phi = phi + (pi + bias_amp*noise[0])*dN + noise[0]*dW[0] + noise[1]*dW[1]
\n", + "
  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_4 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_5 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_5 < 0) {\n",
+       "    __pyx_t_5 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_5 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_5 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_6 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_6 < 0) {\n",
+       "    __pyx_t_6 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_6 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_6 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_phi = (((__pyx_v_phi + ((__pyx_v_pi + (__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_1 * __pyx_v_noise.strides[0]) ))))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_4 * __pyx_v_dW.strides[0]) ))))) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_5 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_6 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 034:
\n", + "
 035:     pi =\\
\n", + "
+036:         pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN +\\
\n", + "
  __pyx_t_7 = __pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_V_prime_by_V_cython(__pyx_v_phi_old); if (unlikely(__pyx_t_7 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L1_error)\n",
+       "
+037:          bias_amp*noise[2]*dN + noise[1]*dW[0] + noise[2]*dW[1]
\n", + "
  __pyx_t_6 = 2;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_6 < 0) {\n",
+       "    __pyx_t_6 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_6 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_6 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 37, __pyx_L1_error)\n",
+       "  }\n",
+       "/* … */\n",
+       "  __pyx_t_5 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_5 < 0) {\n",
+       "    __pyx_t_5 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_5 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_5 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 37, __pyx_L1_error)\n",
+       "  }\n",
+       "/* … */\n",
+       "  __pyx_t_4 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 37, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_3 = 2;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 37, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_1 = 1;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 37, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_pi = ((((__pyx_v_pi - (((3.0 - (0.5 * pow(__pyx_v_pi, 2.0))) * (__pyx_v_pi + __pyx_t_7)) * __pyx_v_dN)) + ((__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_6 * __pyx_v_noise.strides[0]) )))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_5 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_4 * __pyx_v_dW.strides[0]) ))))) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 038:
\n", + "
 039:     # Update the velocity
\n", + "
+040:     if noise[0]>0:  #Need to include the chance the noise is zero
\n", + "
  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 40, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_8 = ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_1 * __pyx_v_noise.strides[0]) ))) > 0.0);\n",
+       "  if (__pyx_t_8) {\n",
+       "/* … */\n",
+       "    goto __pyx_L3;\n",
+       "  }\n",
+       "
 041:         # Use the standard form for the weight calculation
\n", + "
+042:         A += bias_amp*(0.5*bias_amp*dN + dW[0])
\n", + "
    __pyx_t_1 = 0;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_1 < 0) {\n",
+       "      __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 42, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_v_A = (__pyx_v_A + (__pyx_v_bias_amp * (((0.5 * __pyx_v_bias_amp) * __pyx_v_dN) + (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) ))))));\n",
+       "
 043:     else:
\n", + "
 044:         # No change as no noise is applied.
\n", + "
+045:         A += 0.
\n", + "
  /*else*/ {\n",
+       "    __pyx_v_A = (__pyx_v_A + 0.);\n",
+       "  }\n",
+       "  __pyx_L3:;\n",
+       "
+046:     return [phi, pi, A]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_phi); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 46, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_9);\n",
+       "  __pyx_t_10 = PyFloat_FromDouble(__pyx_v_pi); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 46, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_10);\n",
+       "  __pyx_t_11 = PyFloat_FromDouble(__pyx_v_A); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 46, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_11);\n",
+       "  __pyx_t_12 = PyList_New(3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 46, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_12);\n",
+       "  __Pyx_GIVEREF(__pyx_t_9);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 0, __pyx_t_9)) __PYX_ERR(0, 46, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_10);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 1, __pyx_t_10)) __PYX_ERR(0, 46, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_11);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 2, __pyx_t_11)) __PYX_ERR(0, 46, __pyx_L1_error);\n",
+       "  __pyx_t_9 = 0;\n",
+       "  __pyx_t_10 = 0;\n",
+       "  __pyx_t_11 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_12);\n",
+       "  __pyx_t_12 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 047:
\n", + "
 048:
\n", + "
 049: #A let's us calculate the bias w=e^-A is the bias, which propagated along with
\n", + "
 050: #the importance sample path.
\n", + "
 051: #See Eq. (33) of arXiv:nucl-th/9809075v1 for more info
\n", + "
+052: cdef list simulation_diff_general_end(double x_in, double y_in, double t_in,\\
\n", + "
static PyObject *__pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_simulation_diff_general_end(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, PyObject *__pyx_v_rng) {\n",
+       "  double __pyx_v_t;\n",
+       "  double __pyx_v_sqrt_dt;\n",
+       "  double __pyx_v_x;\n",
+       "  double __pyx_v_y;\n",
+       "  double __pyx_v_A;\n",
+       "  int __pyx_v_i;\n",
+       "  int __pyx_v_end_cond_value;\n",
+       "  int __pyx_v_len_rand_nums;\n",
+       "  int __pyx_v_reduced_step;\n",
+       "  int __pyx_v_num_steps;\n",
+       "  __Pyx_memviewslice __pyx_v_rand_nums = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_dW = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_noise = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_4);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1.simulation_diff_general_end\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_dW, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_noise, 1);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 053:                           double t_f, double dt, double bias_amp, double phi_end_in, noise_list, rng):
\n", + "
 054:     cdef double t, sqrt_dt, x, y, z, A
\n", + "
+055:     cdef int i = 0
\n", + "
  __pyx_v_i = 0;\n",
+       "
 056:     cdef int end_cond_value
\n", + "
+057:     cdef int len_rand_nums = 1000
\n", + "
  __pyx_v_len_rand_nums = 0x3E8;\n",
+       "
+058:     cdef int reduced_step = 0
\n", + "
  __pyx_v_reduced_step = 0;\n",
+       "
+059:     cdef int num_steps = 0
\n", + "
  __pyx_v_num_steps = 0;\n",
+       "
 060:
\n", + "
 061:     cdef double [:, :] rand_nums
\n", + "
 062:     cdef double [:] dW
\n", + "
 063:     cdef double [:] noise
\n", + "
 064:
\n", + "
+065:     t = t_in
\n", + "
  __pyx_v_t = __pyx_v_t_in;\n",
+       "
+066:     x = x_in
\n", + "
  __pyx_v_x = __pyx_v_x_in;\n",
+       "
+067:     y = y_in
\n", + "
  __pyx_v_y = __pyx_v_y_in;\n",
+       "
+068:     sqrt_dt = dt**0.5
\n", + "
  __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+069:     A = 0.0
\n", + "
  __pyx_v_A = 0.0;\n",
+       "
+070:     rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 70, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_INCREF(__pyx_int_2);\n",
+       "  __Pyx_GIVEREF(__pyx_int_2);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_2)) __PYX_ERR(0, 70, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error);\n",
+       "  __pyx_t_3 = 0;\n",
+       "  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_4) < 0) __PYX_ERR(0, 70, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__9, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 70, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 70, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_rand_nums = __pyx_t_5;\n",
+       "  __pyx_t_5.memview = NULL;\n",
+       "  __pyx_t_5.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__9 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 70, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__9);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__9);\n",
+       "
+071:     dW = rand_nums[:, 0]
\n", + "
  __pyx_t_6.data = __pyx_v_rand_nums.data;\n",
+       "  __pyx_t_6.memview = __pyx_v_rand_nums.memview;\n",
+       "  __PYX_INC_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __pyx_t_6.shape[0] = __pyx_v_rand_nums.shape[0];\n",
+       "__pyx_t_6.strides[0] = __pyx_v_rand_nums.strides[0];\n",
+       "    __pyx_t_6.suboffsets[0] = -1;\n",
+       "\n",
+       "{\n",
+       "    Py_ssize_t __pyx_tmp_idx = 0;\n",
+       "        Py_ssize_t __pyx_tmp_shape = __pyx_v_rand_nums.shape[1];\n",
+       "    Py_ssize_t __pyx_tmp_stride = __pyx_v_rand_nums.strides[1];\n",
+       "        if (__pyx_tmp_idx < 0)\n",
+       "            __pyx_tmp_idx += __pyx_tmp_shape;\n",
+       "        if (unlikely(!__Pyx_is_valid_index(__pyx_tmp_idx, __pyx_tmp_shape))) {\n",
+       "            PyErr_SetString(PyExc_IndexError,\n",
+       "                            \"Index out of bounds (axis 1)\");\n",
+       "            __PYX_ERR(0, 71, __pyx_L1_error)\n",
+       "        }\n",
+       "        __pyx_t_6.data += __pyx_tmp_idx * __pyx_tmp_stride;\n",
+       "}\n",
+       "\n",
+       "__pyx_v_dW = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "
+072:     noise = noise_list[:, 0]
\n", + "
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_tuple__10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 72, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 72, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_noise = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_slice__5, __pyx_int_0); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 72, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__10);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__10);\n",
+       "
 073:
\n", + "
+074:     while t<t_f:
\n", + "
  while (1) {\n",
+       "    __pyx_t_7 = (__pyx_v_t < __pyx_v_t_f);\n",
+       "    if (!__pyx_t_7) break;\n",
+       "
 075:         # Scale the step varaince to the dt used
\n", + "
+076:         dW[0] = sqrt_dt*rand_nums[0, i]
\n", + "
    __pyx_t_8 = 0;\n",
+       "    __pyx_t_9 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 76, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 76, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_8 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_9 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
+077:         dW[1] = sqrt_dt*rand_nums[1, i]
\n", + "
    __pyx_t_9 = 1;\n",
+       "    __pyx_t_8 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 77, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 77, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_9 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_8 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
 078:         # Find the noise from the list provided
\n", + "
+079:         noise[0] = noise_list[0, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_0);\n",
+       "    __Pyx_GIVEREF(__pyx_int_0);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_0)) __PYX_ERR(0, 79, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
+080:         noise[1] = noise_list[1, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_1);\n",
+       "    __Pyx_GIVEREF(__pyx_int_1);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_1)) __PYX_ERR(0, 80, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
+081:         noise[2] = noise_list[2, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 81, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_2);\n",
+       "    __Pyx_GIVEREF(__pyx_int_2);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_2)) __PYX_ERR(0, 81, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 81, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 81, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 81, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 2;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 81, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
 082:         # Define the Wiener step, using the pre-drawn random numbers.
\n", + "
 083:         # Step in x and A simultanioues
\n", + "
+084:         [x, y, A] =\\
\n", + "
    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_13 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "    __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    __pyx_v_x = __pyx_t_12;\n",
+       "    __pyx_v_y = __pyx_t_13;\n",
+       "    __pyx_v_A = __pyx_t_14;\n",
+       "
+085:             update(x, y, A, t, dt, dW, noise, bias_amp)
\n", + "
    __pyx_t_4 = __pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_update(__pyx_v_x, __pyx_v_y, __pyx_v_A, __pyx_v_t, __pyx_v_dt, __pyx_v_dW, __pyx_v_noise, __pyx_v_bias_amp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    if (likely(__pyx_t_4 != Py_None)) {\n",
+       "      PyObject* sequence = __pyx_t_4;\n",
+       "      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "      if (unlikely(size != 3)) {\n",
+       "        if (size > 3) __Pyx_RaiseTooManyValuesError(3);\n",
+       "        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "        __PYX_ERR(0, 84, __pyx_L1_error)\n",
+       "      }\n",
+       "      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); \n",
+       "      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); \n",
+       "      __Pyx_INCREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_1);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      #else\n",
+       "      __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      #endif\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    } else {\n",
+       "      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 84, __pyx_L1_error)\n",
+       "    }\n",
+       "
+086:         t += dt
\n", + "
    __pyx_v_t = (__pyx_v_t + __pyx_v_dt);\n",
+       "
+087:         i += 1
\n", + "
    __pyx_v_i = (__pyx_v_i + 1);\n",
+       "
+088:         num_steps += 1
\n", + "
    __pyx_v_num_steps = (__pyx_v_num_steps + 1);\n",
+       "
 089:         # Using 1/0 for True/False
\n", + "
+090:         end_cond_value = end_cond(x, y, t, phi_end_in)
\n", + "
    __pyx_t_10 = __pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_end_cond(__pyx_v_x, __pyx_v_y, __pyx_v_t, __pyx_v_phi_end_in); if (unlikely(__pyx_t_10 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L1_error)\n",
+       "    __pyx_v_end_cond_value = __pyx_t_10;\n",
+       "
+091:         if end_cond_value == 1:
\n", + "
    __pyx_t_7 = (__pyx_v_end_cond_value == 1);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "
+092:             break
\n", + "
      goto __pyx_L4_break;\n",
+       "
+093:         elif end_cond_value == -1 and reduced_step == 0:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == -1L);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L6_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 0);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L6_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "      goto __pyx_L5;\n",
+       "    }\n",
+       "
+094:             dt = dt/100
\n", + "
      __pyx_v_dt = (__pyx_v_dt / 100.0);\n",
+       "
+095:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+096:             reduced_step = 1
\n", + "
      __pyx_v_reduced_step = 1;\n",
+       "
+097:         elif end_cond_value == 0 and reduced_step == 1:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == 0);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L8_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 1);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L8_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "    __pyx_L5:;\n",
+       "
+098:             dt = 100*dt
\n", + "
      __pyx_v_dt = (100.0 * __pyx_v_dt);\n",
+       "
+099:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+100:             reduced_step = 0
\n", + "
      __pyx_v_reduced_step = 0;\n",
+       "
 101:         # If all of the random numbers have been used up, need to update them.
\n", + "
 102:         # This should still be more efficient than drawing a new random number
\n", + "
 103:         # each time.
\n", + "
+104:         if i == len_rand_nums:
\n", + "
    __pyx_t_7 = (__pyx_v_i == __pyx_v_len_rand_nums);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "  }\n",
+       "  __pyx_L4_break:;\n",
+       "
+105:             rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_4);\n",
+       "      __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 105, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_int_2);\n",
+       "      __Pyx_GIVEREF(__pyx_int_2);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_2)) __PYX_ERR(0, 105, __pyx_L1_error);\n",
+       "      __Pyx_GIVEREF(__pyx_t_1);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error);\n",
+       "      __pyx_t_1 = 0;\n",
+       "      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_size, __pyx_t_2) < 0) __PYX_ERR(0, 105, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__9, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "      __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 105, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "      __pyx_v_rand_nums = __pyx_t_5;\n",
+       "      __pyx_t_5.memview = NULL;\n",
+       "      __pyx_t_5.data = NULL;\n",
+       "
+106:             i = 0
\n", + "
      __pyx_v_i = 0;\n",
+       "
+107:     return [t, e**(-A)]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_16 = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_e, 0), __pyx_t_double_complex_from_parts((-__pyx_v_A), 0));\n",
+       "  __pyx_t_3 = __pyx_Py_FromSoftComplex(__pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_GIVEREF(__pyx_t_2);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error);\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_4);\n",
+       "  __pyx_t_4 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 108:
\n", + "
 109:
\n", + "
+110: cpdef importance_sampling_simulations_2dim_2d_noise_full(double x_in, double y_in, double t_in, double t_f,
\n", + "
static PyObject *__pyx_pw_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_1importance_sampling_simulations_2dim_2d_noise_full(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyObject *__pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_importance_sampling_simulations_2dim_2d_noise_full(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, CYTHON_UNUSED int __pyx_skip_dispatch) {\n",
+       "  PyObject *__pyx_v_rng = NULL;\n",
+       "  PyObject *__pyx_v_results = NULL;\n",
+       "  PyObject *__pyx_v_ts = NULL;\n",
+       "  PyObject *__pyx_v_ws = NULL;\n",
+       "  CYTHON_UNUSED int __pyx_7genexpr__pyx_v_i;\n",
+       "  long __pyx_8genexpr1__pyx_v_j;\n",
+       "  int __pyx_8genexpr2__pyx_v_i;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1.importance_sampling_simulations_2dim_2d_noise_full\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XDECREF(__pyx_v_rng);\n",
+       "  __Pyx_XDECREF(__pyx_v_results);\n",
+       "  __Pyx_XDECREF(__pyx_v_ts);\n",
+       "  __Pyx_XDECREF(__pyx_v_ws);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "/* Python wrapper */\n",
+       "static PyObject *__pyx_pw_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_1importance_sampling_simulations_2dim_2d_noise_full(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyMethodDef __pyx_mdef_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_1importance_sampling_simulations_2dim_2d_noise_full = {\"importance_sampling_simulations_2dim_2d_noise_full\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_1importance_sampling_simulations_2dim_2d_noise_full, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
+       "static PyObject *__pyx_pw_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_1importance_sampling_simulations_2dim_2d_noise_full(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       ") {\n",
+       "  double __pyx_v_x_in;\n",
+       "  double __pyx_v_y_in;\n",
+       "  double __pyx_v_t_in;\n",
+       "  double __pyx_v_t_f;\n",
+       "  double __pyx_v_dt;\n",
+       "  int __pyx_v_num_runs;\n",
+       "  double __pyx_v_bias_amp;\n",
+       "  double __pyx_v_phi_end_in;\n",
+       "  PyObject *__pyx_v_noise_list = 0;\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  CYTHON_UNUSED Py_ssize_t __pyx_nargs;\n",
+       "  #endif\n",
+       "  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;\n",
+       "  PyObject *__pyx_r = 0;\n",
+       "  __Pyx_RefNannyDeclarations\n",
+       "  __Pyx_RefNannySetupContext(\"importance_sampling_simulations_2dim_2d_noise_full (wrapper)\", 0);\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  #if CYTHON_ASSUME_SAFE_MACROS\n",
+       "  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);\n",
+       "  #else\n",
+       "  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;\n",
+       "  #endif\n",
+       "  #endif\n",
+       "  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);\n",
+       "  {\n",
+       "    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_in,&__pyx_n_s_y_in,&__pyx_n_s_t_in,&__pyx_n_s_t_f,&__pyx_n_s_dt,&__pyx_n_s_num_runs,&__pyx_n_s_bias_amp,&__pyx_n_s_phi_end_in,&__pyx_n_s_noise_list,0};\n",
+       "  PyObject* values[9] = {0,0,0,0,0,0,0,0,0};\n",
+       "    if (__pyx_kwds) {\n",
+       "      Py_ssize_t kw_args;\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  0: break;\n",
+       "        default: goto __pyx_L5_argtuple_error;\n",
+       "      }\n",
+       "      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  0:\n",
+       "        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_x_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        else goto __pyx_L5_argtuple_error;\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1:\n",
+       "        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_y_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_2d_noise_full\", 1, 9, 9, 1); __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2:\n",
+       "        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_2d_noise_full\", 1, 9, 9, 2); __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3:\n",
+       "        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_f)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_2d_noise_full\", 1, 9, 9, 3); __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4:\n",
+       "        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dt)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_2d_noise_full\", 1, 9, 9, 4); __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5:\n",
+       "        if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_num_runs)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[5]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_2d_noise_full\", 1, 9, 9, 5); __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6:\n",
+       "        if (likely((values[6] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bias_amp)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[6]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_2d_noise_full\", 1, 9, 9, 6); __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7:\n",
+       "        if (likely((values[7] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_phi_end_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[7]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_2d_noise_full\", 1, 9, 9, 7); __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8:\n",
+       "        if (likely((values[8] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_noise_list)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[8]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_2d_noise_full\", 1, 9, 9, 8); __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "        }\n",
+       "      }\n",
+       "      if (unlikely(kw_args > 0)) {\n",
+       "        const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
+       "        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"importance_sampling_simulations_2dim_2d_noise_full\") < 0)) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "      }\n",
+       "    } else if (unlikely(__pyx_nargs != 9)) {\n",
+       "      goto __pyx_L5_argtuple_error;\n",
+       "    } else {\n",
+       "      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "      values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "      values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "      values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "      values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "    }\n",
+       "    __pyx_v_x_in = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "    __pyx_v_y_in = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_y_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "    __pyx_v_t_in = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_t_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "    __pyx_v_t_f = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_t_f == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "    __pyx_v_dt = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_dt == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 111, __pyx_L3_error)\n",
+       "    __pyx_v_num_runs = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_num_runs == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 111, __pyx_L3_error)\n",
+       "    __pyx_v_bias_amp = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_bias_amp == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 111, __pyx_L3_error)\n",
+       "    __pyx_v_phi_end_in = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_phi_end_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 111, __pyx_L3_error)\n",
+       "    __pyx_v_noise_list = values[8];\n",
+       "  }\n",
+       "  goto __pyx_L6_skip;\n",
+       "  __pyx_L5_argtuple_error:;\n",
+       "  __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_2d_noise_full\", 1, 9, 9, __pyx_nargs); __PYX_ERR(0, 110, __pyx_L3_error)\n",
+       "  __pyx_L6_skip:;\n",
+       "  goto __pyx_L4_argument_unpacking_done;\n",
+       "  __pyx_L3_error:;\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1.importance_sampling_simulations_2dim_2d_noise_full\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return NULL;\n",
+       "  __pyx_L4_argument_unpacking_done:;\n",
+       "  __pyx_r = __pyx_pf_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_importance_sampling_simulations_2dim_2d_noise_full(__pyx_self, __pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list);\n",
+       "  int __pyx_lineno = 0;\n",
+       "  const char *__pyx_filename = NULL;\n",
+       "  int __pyx_clineno = 0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "static PyObject *__pyx_pf_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_importance_sampling_simulations_2dim_2d_noise_full(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list) {\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = __pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_importance_sampling_simulations_2dim_2d_noise_full(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1.importance_sampling_simulations_2dim_2d_noise_full\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = NULL;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "/* … */\n",
+       "  __pyx_tuple__22 = PyTuple_Pack(9, __pyx_n_s_x_in, __pyx_n_s_y_in, __pyx_n_s_t_in, __pyx_n_s_t_f, __pyx_n_s_dt, __pyx_n_s_num_runs, __pyx_n_s_bias_amp, __pyx_n_s_phi_end_in, __pyx_n_s_noise_list); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 110, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__22);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__22);\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_1importance_sampling_simulations_2dim_2d_noise_full, 0, __pyx_n_s_importance_sampling_simulations, NULL, __pyx_n_s_cython_magic_e7ee499f1eb5101008, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_importance_sampling_simulations, __pyx_t_7) < 0) __PYX_ERR(0, 110, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 111:                                            double dt, int num_runs, double bias_amp, double phi_end_in,
\n", + "
 112:                                                 noise_list):
\n", + "
 113:     # As this variable is global, I can just redfine it hear
\n", + "
+114:     rng = np.random.default_rng()
\n", + "
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_default_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "  __pyx_t_3 = NULL;\n",
+       "  __pyx_t_4 = 0;\n",
+       "  #if CYTHON_UNPACK_METHODS\n",
+       "  if (likely(PyMethod_Check(__pyx_t_2))) {\n",
+       "    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);\n",
+       "    if (likely(__pyx_t_3)) {\n",
+       "      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      __Pyx_INCREF(function);\n",
+       "      __Pyx_DECREF_SET(__pyx_t_2, function);\n",
+       "      __pyx_t_4 = 1;\n",
+       "    }\n",
+       "  }\n",
+       "  #endif\n",
+       "  {\n",
+       "    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};\n",
+       "    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);\n",
+       "    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 114, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  }\n",
+       "  __pyx_v_rng = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "
 115:     results =\\
\n", + "
+116:         [simulation_diff_general_end(x_in, y_in, t_in, t_f, dt, bias_amp, phi_end_in, noise_list, rng)\\
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "/* … */\n",
+       "      __pyx_t_2 = __pyx_f_54_cython_magic_e7ee499f1eb5101008b4da7d0362848d906803e1_simulation_diff_general_end(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, __pyx_v_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  __pyx_v_results = ((PyObject*)__pyx_t_1);\n",
+       "  __pyx_t_1 = 0;\n",
+       "
+117:          for i in range(num_runs)]
\n", + "
    __pyx_t_4 = __pyx_v_num_runs;\n",
+       "    __pyx_t_5 = __pyx_t_4;\n",
+       "    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "      __pyx_7genexpr__pyx_v_i = __pyx_t_6;\n",
+       "
 118:
\n", + "
 119:
\n", + "
+120:     ts, ws = [[results[i][j] for i in range(num_runs)] for j in range(2)]
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    for (__pyx_t_7 = 0; __pyx_t_7 < 2; __pyx_t_7+=1) {\n",
+       "      __pyx_8genexpr1__pyx_v_j = __pyx_t_7;\n",
+       "      { /* enter inner scope */\n",
+       "        __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error)\n",
+       "        __Pyx_GOTREF(__pyx_t_2);\n",
+       "        __pyx_t_4 = __pyx_v_num_runs;\n",
+       "        __pyx_t_5 = __pyx_t_4;\n",
+       "        for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "          __pyx_8genexpr2__pyx_v_i = __pyx_t_6;\n",
+       "          __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_results, __pyx_8genexpr2__pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 120, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_3);\n",
+       "          __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, __pyx_8genexpr1__pyx_v_j, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 120, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_8);\n",
+       "          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "          if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 120, __pyx_L1_error)\n",
+       "          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;\n",
+       "        }\n",
+       "      } /* exit inner scope */\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 120, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  if (1) {\n",
+       "    PyObject* sequence = __pyx_t_1;\n",
+       "    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "    if (unlikely(size != 2)) {\n",
+       "      if (size > 2) __Pyx_RaiseTooManyValuesError(2);\n",
+       "      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "      __PYX_ERR(0, 120, __pyx_L1_error)\n",
+       "    }\n",
+       "    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "    __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "    __pyx_t_8 = PyList_GET_ITEM(sequence, 1); \n",
+       "    __Pyx_INCREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_t_8);\n",
+       "    #else\n",
+       "    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 120, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_8);\n",
+       "    #endif\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  }\n",
+       "  __pyx_v_ts = __pyx_t_2;\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_v_ws = __pyx_t_8;\n",
+       "  __pyx_t_8 = 0;\n",
+       "
+121:     return ts, ws
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __Pyx_INCREF(__pyx_v_ts);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ts);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_ts)) __PYX_ERR(0, 121, __pyx_L1_error);\n",
+       "  __Pyx_INCREF(__pyx_v_ws);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ws);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ws)) __PYX_ERR(0, 121, __pyx_L1_error);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%cython -a\n", + "\n", + "import numpy as np\n", + "\n", + "cdef double e = 2.718281828459045\n", + "cdef double pi_const = 3.141592653589793\n", + "cdef double phi_star = 1.0\n", + "cdef double A_plus = 1e-14\n", + "cdef double A_minus = 1e-17\n", + "cdef double V_0 = 2.871906714642027e-12\n", + "cdef double diff_const = 1.5572025557368665e-07\n", + "cdef double phi_old\n", + "\n", + "\n", + "cdef double V_prime_by_V_cython(double phi):\n", + " if phi > phi_star:\n", + " return A_plus/(V_0 + A_plus*(phi - phi_star))\n", + " elif phi <= phi_star:\n", + " return A_minus/(V_0 + A_minus*(phi - phi_star))\n", + " \n", + "cdef int end_cond(double phi, double pi, double N, double phi_end):\n", + " if phi0: #Need to include the chance the noise is zero\n", + " # Use the standard form for the weight calculation\n", + " A += bias_amp*(0.5*bias_amp*dN + dW[0])\n", + " else:\n", + " # No change as no noise is applied.\n", + " A += 0.\n", + " return [phi, pi, A]\n", + "\n", + "\n", + "#A let's us calculate the bias w=e^-A is the bias, which propagated along with \n", + "#the importance sample path.\n", + "#See Eq. (33) of arXiv:nucl-th/9809075v1 for more info\n", + "cdef list simulation_diff_general_end(double x_in, double y_in, double t_in,\\\n", + " double t_f, double dt, double bias_amp, double phi_end_in, noise_list, rng):\n", + " cdef double t, sqrt_dt, x, y, z, A\n", + " cdef int i = 0\n", + " cdef int end_cond_value\n", + " cdef int len_rand_nums = 1000\n", + " cdef int reduced_step = 0\n", + " cdef int num_steps = 0\n", + " \n", + " cdef double [:, :] rand_nums\n", + " cdef double [:] dW\n", + " cdef double [:] noise\n", + "\n", + " t = t_in\n", + " x = x_in\n", + " y = y_in\n", + " sqrt_dt = dt**0.5\n", + " A = 0.0\n", + " rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))\n", + " dW = rand_nums[:, 0]\n", + " noise = noise_list[:, 0]\n", + "\n", + " while t" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bin_centres, heights, errors = fpt.numerics.re_processing(Ns, estimator=\"naive\", min_bin_size=100)\n", + "# Apply the delta N formula\n", + "bin_centres = np.array(bin_centres) - find_cg_time(k_end_scale_later, sigma, N_sim_end_later)\n", + "\n", + "plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7, label=\"2D, $\\sigma=$\"+str(sigma),\n", + " color=color[0])\n", + "plt.yscale('log')\n", + "plt.legend(fontsize=18)\n", + "plt.xlabel(r'$\\delta \\mathcal{N}$')\n", + "plt.ylabel(r'$P(\\delta \\mathcal{N})$')\n", + "plt.title(r\"Piece-wise, $\\delta \\phi_{\\mathrm{h}}$\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clearly given by a Gaussian!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we want to compare this with the Gaussian prediction. To do this we need to find the power spectrum data in and integrate to find the variance." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "N_values_for_plot = np.linspace(N_sim_start, N_sim_end, 1000)\n", + "N_eval = N_end-5\n", + "\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_sim_start))\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_sim_start))\n", + "k_values_integrated_normed = aH_interpolation(N_values_for_plot)/aH_interpolation(N_sim_start)\n", + "\n", + "power_specrum_values = np.zeros(len(N_values_for_plot))\n", + "for j in range(len(N_values_for_plot)):\n", + " N_mode_exit = N_values_for_plot[j]\n", + " # Find when this mode left the horizon\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " delta_phi = analytical_delta_phi(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " R = delta_phi/np.sqrt(2*epsilon1_interpolation(N_eval))\n", + " power_specrum_values[j] = power_spectrum_func(k, R)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also need a function to do the integration." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def analytical_fpt_variance_func(power_spectrum, k_values):\n", + " ln_k_values = np.log(k_values)\n", + " return trapezoid(power_spectrum/k_values, x=k_values)\n", + "\n", + "def gaussian_pdf_generator(std, mean=0):\n", + " def pdf(x):\n", + " expo_term = np.exp(-0.5*((x-mean)/std)**2)\n", + " norm = 1/(std*(2*np.pi)**0.5)\n", + " return norm*expo_term\n", + " return pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "analytical_fpt_variance = analytical_fpt_variance_func(power_specrum_values, k_values_integrated_normed)\n", + "analytical_fpt_std = analytical_fpt_variance**0.5\n", + "gaussian_pdf = gaussian_pdf_generator(analytical_fpt_std, mean=0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.12190137996950524" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "analytical_fpt_std" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7, label=\"2D, $\\sigma=$\"+str(sigma),\n", + " color=color[0])\n", + "plt.plot(bin_centres, gaussian_pdf(bin_centres), color=\"k\",\n", + " label=\"Gaussian\")\n", + "plt.yscale('log')\n", + "plt.legend(fontsize=18)\n", + "plt.xlabel(r'$\\delta \\mathcal{N}$')\n", + "plt.ylabel(r'$P(\\delta \\mathcal{N})$')\n", + "plt.title(r\"Gaussian bump, $\\delta \\phi_{\\mathrm{h}}$\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is clearly very Gaussian!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1D noise\n", + "Now let's investigate the effect of using a 2D noise. This is the same as the 2D case but the Cython code is changed." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " Cython: _cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.pyx\n", + " \n", + "\n", + "\n", + "

Generated by Cython 3.0.7

\n", + "

\n", + " Yellow lines hint at Python interaction.
\n", + " Click on a line that starts with a \"+\" to see the C code that Cython generated for it.\n", + "

\n", + "
 001:
\n", + "
+002: import numpy as np
\n", + "
  __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 003:
\n", + "
+004: cdef double e = 2.718281828459045
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_e = 2.718281828459045;\n",
+       "
+005: cdef double pi_const = 3.141592653589793
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_pi_const = 3.141592653589793;\n",
+       "
+006: cdef double phi_star = 1.0
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star = 1.0;\n",
+       "
+007: cdef double A_plus = 1e-14
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_plus = 1e-14;\n",
+       "
+008: cdef double A_minus = 1e-17
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_minus = 1e-17;\n",
+       "
+009: cdef double V_0 = 2.871906714642027e-12
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_0 = 2.871906714642027e-12;\n",
+       "
+010: cdef double diff_const = 1.5572025557368665e-07
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_diff_const = 1.5572025557368665e-07;\n",
+       "
 011: cdef double phi_old
\n", + "
 012:
\n", + "
 013:
\n", + "
+014: cdef double V_prime_by_V_cython(double phi):
\n", + "
static double __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_prime_by_V_cython(double __pyx_v_phi) {\n",
+       "  double __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_r = 0;\n",
+       "  goto __pyx_L0;\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.V_prime_by_V_cython\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = -1;\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+015:     if phi > phi_star:
\n", + "
  __pyx_t_1 = (__pyx_v_phi > __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+016:         return A_plus/(V_0 + A_plus*(phi - phi_star))
\n", + "
    __pyx_t_2 = (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_0 + (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_plus * (__pyx_v_phi - __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star)));\n",
+       "    if (unlikely(__pyx_t_2 == 0)) {\n",
+       "      PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "      __PYX_ERR(0, 16, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_r = (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_plus / __pyx_t_2);\n",
+       "    goto __pyx_L0;\n",
+       "
+017:     elif phi <= phi_star:
\n", + "
  __pyx_t_1 = (__pyx_v_phi <= __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+018:         return A_minus/(V_0 + A_minus*(phi - phi_star))
\n", + "
    __pyx_t_2 = (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_0 + (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_minus * (__pyx_v_phi - __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star)));\n",
+       "    if (unlikely(__pyx_t_2 == 0)) {\n",
+       "      PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "      __PYX_ERR(0, 18, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_r = (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_minus / __pyx_t_2);\n",
+       "    goto __pyx_L0;\n",
+       "
 019:
\n", + "
+020: cdef int end_cond(double phi, double pi, double N, double phi_end):
\n", + "
static int __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_end_cond(double __pyx_v_phi, CYTHON_UNUSED double __pyx_v_pi, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_phi_end) {\n",
+       "  int __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+021:     if phi<phi_end:
\n", + "
  __pyx_t_1 = (__pyx_v_phi < __pyx_v_phi_end);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+022:         return 1
\n", + "
    __pyx_r = 1;\n",
+       "    goto __pyx_L0;\n",
+       "
 023:     else:
\n", + "
+024:         return 0
\n", + "
  /*else*/ {\n",
+       "    __pyx_r = 0;\n",
+       "    goto __pyx_L0;\n",
+       "  }\n",
+       "
 025:
\n", + "
 026:
\n", + "
+027: cdef list update(double phi, double pi, double A, double N, double dN, double [:] dW, double [:] noise,
\n", + "
static PyObject *__pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_update(double __pyx_v_phi, double __pyx_v_pi, double __pyx_v_A, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_dN, __Pyx_memviewslice __pyx_v_dW, __Pyx_memviewslice __pyx_v_noise, double __pyx_v_bias_amp) {\n",
+       "  double __pyx_v_phi_old;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_7);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_XDECREF(__pyx_t_9);\n",
+       "  __Pyx_XDECREF(__pyx_t_10);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.update\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 028:                  double bias_amp):
\n", + "
 029:     # Store old phi value to be used in calculating velocity
\n", + "
+030:     phi_old = phi
\n", + "
  __pyx_v_phi_old = __pyx_v_phi;\n",
+       "
 031:     # Update field position
\n", + "
 032:     # If noise is zero, no bias is automatically applied
\n", + "
+033:     phi = phi + (pi + bias_amp*noise[0])*dN + noise[0]*dW[0]
\n", + "
  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_4 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_phi = ((__pyx_v_phi + ((__pyx_v_pi + (__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_1 * __pyx_v_noise.strides[0]) ))))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_4 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 034:
\n", + "
 035:     # Update the velocity
\n", + "
+036:     if noise[0]>0:  #Need to include the chance the noise is zero
\n", + "
  __pyx_t_4 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 36, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_5 = ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_4 * __pyx_v_noise.strides[0]) ))) > 0.0);\n",
+       "  if (__pyx_t_5) {\n",
+       "/* … */\n",
+       "    goto __pyx_L3;\n",
+       "  }\n",
+       "
 037:         pi =\\
\n", + "
+038:             pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN +\\
\n", + "
    __pyx_t_6 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_prime_by_V_cython(__pyx_v_phi_old); if (unlikely(__pyx_t_6 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error)\n",
+       "
+039:              bias_amp*noise[1]*dN + noise[1]*dW[0]
\n", + "
    __pyx_t_4 = 1;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_4 < 0) {\n",
+       "      __pyx_t_4 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_4 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 39, __pyx_L1_error)\n",
+       "    }\n",
+       "/* … */\n",
+       "    __pyx_t_3 = 1;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_3 < 0) {\n",
+       "      __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 39, __pyx_L1_error)\n",
+       "    }\n",
+       "/* … */\n",
+       "    __pyx_t_1 = 0;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_1 < 0) {\n",
+       "      __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 39, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_v_pi = (((__pyx_v_pi - (((3.0 - (0.5 * pow(__pyx_v_pi, 2.0))) * (__pyx_v_pi + __pyx_t_6)) * __pyx_v_dN)) + ((__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_4 * __pyx_v_noise.strides[0]) )))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 040:
\n", + "
 041:         # Use the standard form for the weight calculation
\n", + "
+042:         A += bias_amp*(0.5*bias_amp*dN + dW[0])
\n", + "
    __pyx_t_1 = 0;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_1 < 0) {\n",
+       "      __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 42, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_v_A = (__pyx_v_A + (__pyx_v_bias_amp * (((0.5 * __pyx_v_bias_amp) * __pyx_v_dN) + (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) ))))));\n",
+       "
 043:     else:
\n", + "
+044:         pi =\\
\n", + "
  /*else*/ {\n",
+       "
+045:             pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN
\n", + "
    __pyx_t_6 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_prime_by_V_cython(__pyx_v_phi_old); if (unlikely(__pyx_t_6 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 45, __pyx_L1_error)\n",
+       "    __pyx_v_pi = (__pyx_v_pi - (((3.0 - (0.5 * pow(__pyx_v_pi, 2.0))) * (__pyx_v_pi + __pyx_t_6)) * __pyx_v_dN));\n",
+       "
 046:         # No change as no noise is applied.
\n", + "
+047:         A += 0.
\n", + "
    __pyx_v_A = (__pyx_v_A + 0.);\n",
+       "  }\n",
+       "  __pyx_L3:;\n",
+       "
 048:
\n", + "
+049:     return [phi, pi, A]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_phi); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_pi); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_8);\n",
+       "  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_A); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_9);\n",
+       "  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_10);\n",
+       "  __Pyx_GIVEREF(__pyx_t_7);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_8);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_8)) __PYX_ERR(0, 49, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_9);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_t_9)) __PYX_ERR(0, 49, __pyx_L1_error);\n",
+       "  __pyx_t_7 = 0;\n",
+       "  __pyx_t_8 = 0;\n",
+       "  __pyx_t_9 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_10);\n",
+       "  __pyx_t_10 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 050:
\n", + "
 051:
\n", + "
 052: #A let's us calculate the bias w=e^-A is the bias, which propagated along with
\n", + "
 053: #the importance sample path.
\n", + "
 054: #See Eq. (33) of arXiv:nucl-th/9809075v1 for more info
\n", + "
+055: cdef list simulation_diff_general_end(double x_in, double y_in, double t_in,\\
\n", + "
static PyObject *__pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_simulation_diff_general_end(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, PyObject *__pyx_v_rng) {\n",
+       "  double __pyx_v_t;\n",
+       "  double __pyx_v_sqrt_dt;\n",
+       "  double __pyx_v_x;\n",
+       "  double __pyx_v_y;\n",
+       "  double __pyx_v_A;\n",
+       "  int __pyx_v_i;\n",
+       "  int __pyx_v_end_cond_value;\n",
+       "  int __pyx_v_len_rand_nums;\n",
+       "  int __pyx_v_reduced_step;\n",
+       "  int __pyx_v_num_steps;\n",
+       "  __Pyx_memviewslice __pyx_v_rand_nums = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_dW = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_noise = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_4);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.simulation_diff_general_end\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_dW, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_noise, 1);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 056:                           double t_f, double dt, double bias_amp, double phi_end_in, noise_list, rng):
\n", + "
 057:     cdef double t, sqrt_dt, x, y, z, A
\n", + "
+058:     cdef int i = 0
\n", + "
  __pyx_v_i = 0;\n",
+       "
 059:     cdef int end_cond_value
\n", + "
+060:     cdef int len_rand_nums = 1000
\n", + "
  __pyx_v_len_rand_nums = 0x3E8;\n",
+       "
+061:     cdef int reduced_step = 0
\n", + "
  __pyx_v_reduced_step = 0;\n",
+       "
+062:     cdef int num_steps = 0
\n", + "
  __pyx_v_num_steps = 0;\n",
+       "
 063:
\n", + "
 064:     cdef double [:, :] rand_nums
\n", + "
 065:     cdef double [:] dW
\n", + "
 066:     cdef double [:] noise
\n", + "
 067:
\n", + "
+068:     t = t_in
\n", + "
  __pyx_v_t = __pyx_v_t_in;\n",
+       "
+069:     x = x_in
\n", + "
  __pyx_v_x = __pyx_v_x_in;\n",
+       "
+070:     y = y_in
\n", + "
  __pyx_v_y = __pyx_v_y_in;\n",
+       "
+071:     sqrt_dt = dt**0.5
\n", + "
  __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+072:     A = 0.0
\n", + "
  __pyx_v_A = 0.0;\n",
+       "
+073:     rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_INCREF(__pyx_int_2);\n",
+       "  __Pyx_GIVEREF(__pyx_int_2);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_2)) __PYX_ERR(0, 73, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error);\n",
+       "  __pyx_t_3 = 0;\n",
+       "  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_4) < 0) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__9, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_rand_nums = __pyx_t_5;\n",
+       "  __pyx_t_5.memview = NULL;\n",
+       "  __pyx_t_5.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__9 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__9);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__9);\n",
+       "
+074:     dW = rand_nums[:, 0]
\n", + "
  __pyx_t_6.data = __pyx_v_rand_nums.data;\n",
+       "  __pyx_t_6.memview = __pyx_v_rand_nums.memview;\n",
+       "  __PYX_INC_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __pyx_t_6.shape[0] = __pyx_v_rand_nums.shape[0];\n",
+       "__pyx_t_6.strides[0] = __pyx_v_rand_nums.strides[0];\n",
+       "    __pyx_t_6.suboffsets[0] = -1;\n",
+       "\n",
+       "{\n",
+       "    Py_ssize_t __pyx_tmp_idx = 0;\n",
+       "        Py_ssize_t __pyx_tmp_shape = __pyx_v_rand_nums.shape[1];\n",
+       "    Py_ssize_t __pyx_tmp_stride = __pyx_v_rand_nums.strides[1];\n",
+       "        if (__pyx_tmp_idx < 0)\n",
+       "            __pyx_tmp_idx += __pyx_tmp_shape;\n",
+       "        if (unlikely(!__Pyx_is_valid_index(__pyx_tmp_idx, __pyx_tmp_shape))) {\n",
+       "            PyErr_SetString(PyExc_IndexError,\n",
+       "                            \"Index out of bounds (axis 1)\");\n",
+       "            __PYX_ERR(0, 74, __pyx_L1_error)\n",
+       "        }\n",
+       "        __pyx_t_6.data += __pyx_tmp_idx * __pyx_tmp_stride;\n",
+       "}\n",
+       "\n",
+       "__pyx_v_dW = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "
+075:     noise = noise_list[:, 0]
\n", + "
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_tuple__10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 75, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 75, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_noise = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_slice__5, __pyx_int_0); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 75, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__10);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__10);\n",
+       "
 076:
\n", + "
+077:     while t<t_f:
\n", + "
  while (1) {\n",
+       "    __pyx_t_7 = (__pyx_v_t < __pyx_v_t_f);\n",
+       "    if (!__pyx_t_7) break;\n",
+       "
 078:         # Scale the step varaince to the dt used
\n", + "
+079:         dW[0] = sqrt_dt*rand_nums[0, i]
\n", + "
    __pyx_t_8 = 0;\n",
+       "    __pyx_t_9 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_8 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_9 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
+080:         dW[1] = sqrt_dt*rand_nums[1, i]
\n", + "
    __pyx_t_9 = 1;\n",
+       "    __pyx_t_8 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_9 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_8 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
 081:         # Find the noise from the list provided
\n", + "
+082:         noise[0] = noise_list[0, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_0);\n",
+       "    __Pyx_GIVEREF(__pyx_int_0);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_0)) __PYX_ERR(0, 82, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
+083:         noise[1] = noise_list[1, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_1);\n",
+       "    __Pyx_GIVEREF(__pyx_int_1);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_1)) __PYX_ERR(0, 83, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
 084:         # Define the Wiener step, using the pre-drawn random numbers.
\n", + "
 085:         # Step in x and A simultanioues
\n", + "
+086:         [x, y, A] =\\
\n", + "
    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_13 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "    __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    __pyx_v_x = __pyx_t_12;\n",
+       "    __pyx_v_y = __pyx_t_13;\n",
+       "    __pyx_v_A = __pyx_t_14;\n",
+       "
+087:             update(x, y, A, t, dt, dW, noise, bias_amp)
\n", + "
    __pyx_t_4 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_update(__pyx_v_x, __pyx_v_y, __pyx_v_A, __pyx_v_t, __pyx_v_dt, __pyx_v_dW, __pyx_v_noise, __pyx_v_bias_amp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    if (likely(__pyx_t_4 != Py_None)) {\n",
+       "      PyObject* sequence = __pyx_t_4;\n",
+       "      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "      if (unlikely(size != 3)) {\n",
+       "        if (size > 3) __Pyx_RaiseTooManyValuesError(3);\n",
+       "        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "        __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "      }\n",
+       "      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); \n",
+       "      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); \n",
+       "      __Pyx_INCREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_1);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      #else\n",
+       "      __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      #endif\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    } else {\n",
+       "      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    }\n",
+       "
+088:         t += dt
\n", + "
    __pyx_v_t = (__pyx_v_t + __pyx_v_dt);\n",
+       "
+089:         i += 1
\n", + "
    __pyx_v_i = (__pyx_v_i + 1);\n",
+       "
+090:         num_steps += 1
\n", + "
    __pyx_v_num_steps = (__pyx_v_num_steps + 1);\n",
+       "
 091:         # Using 1/0 for True/False
\n", + "
+092:         end_cond_value = end_cond(x, y, t, phi_end_in)
\n", + "
    __pyx_t_10 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_end_cond(__pyx_v_x, __pyx_v_y, __pyx_v_t, __pyx_v_phi_end_in); if (unlikely(__pyx_t_10 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error)\n",
+       "    __pyx_v_end_cond_value = __pyx_t_10;\n",
+       "
+093:         if end_cond_value == 1:
\n", + "
    __pyx_t_7 = (__pyx_v_end_cond_value == 1);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "
+094:             break
\n", + "
      goto __pyx_L4_break;\n",
+       "
+095:         elif end_cond_value == -1 and reduced_step == 0:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == -1L);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L6_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 0);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L6_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "      goto __pyx_L5;\n",
+       "    }\n",
+       "
+096:             dt = dt/100
\n", + "
      __pyx_v_dt = (__pyx_v_dt / 100.0);\n",
+       "
+097:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+098:             reduced_step = 1
\n", + "
      __pyx_v_reduced_step = 1;\n",
+       "
+099:         elif end_cond_value == 0 and reduced_step == 1:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == 0);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L8_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 1);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L8_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "    __pyx_L5:;\n",
+       "
+100:             dt = 100*dt
\n", + "
      __pyx_v_dt = (100.0 * __pyx_v_dt);\n",
+       "
+101:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+102:             reduced_step = 0
\n", + "
      __pyx_v_reduced_step = 0;\n",
+       "
 103:         # If all of the random numbers have been used up, need to update them.
\n", + "
 104:         # This should still be more efficient than drawing a new random number
\n", + "
 105:         # each time.
\n", + "
+106:         if i == len_rand_nums:
\n", + "
    __pyx_t_7 = (__pyx_v_i == __pyx_v_len_rand_nums);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "  }\n",
+       "  __pyx_L4_break:;\n",
+       "
+107:             rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_4);\n",
+       "      __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_int_2);\n",
+       "      __Pyx_GIVEREF(__pyx_int_2);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_2)) __PYX_ERR(0, 107, __pyx_L1_error);\n",
+       "      __Pyx_GIVEREF(__pyx_t_1);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error);\n",
+       "      __pyx_t_1 = 0;\n",
+       "      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_size, __pyx_t_2) < 0) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__9, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "      __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "      __pyx_v_rand_nums = __pyx_t_5;\n",
+       "      __pyx_t_5.memview = NULL;\n",
+       "      __pyx_t_5.data = NULL;\n",
+       "
+108:             i = 0
\n", + "
      __pyx_v_i = 0;\n",
+       "
+109:     return [t, e**(-A)]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_16 = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_e, 0), __pyx_t_double_complex_from_parts((-__pyx_v_A), 0));\n",
+       "  __pyx_t_3 = __pyx_Py_FromSoftComplex(__pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 109, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 109, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_GIVEREF(__pyx_t_2);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 109, __pyx_L1_error);\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_4);\n",
+       "  __pyx_t_4 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 110:
\n", + "
 111:
\n", + "
+112: cpdef importance_sampling_simulations_2dim_1d_noise(double x_in, double y_in, double t_in, double t_f,
\n", + "
static PyObject *__pyx_pw_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyObject *__pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_importance_sampling_simulations_2dim_1d_noise(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, CYTHON_UNUSED int __pyx_skip_dispatch) {\n",
+       "  PyObject *__pyx_v_rng = NULL;\n",
+       "  PyObject *__pyx_v_results = NULL;\n",
+       "  PyObject *__pyx_v_ts = NULL;\n",
+       "  PyObject *__pyx_v_ws = NULL;\n",
+       "  CYTHON_UNUSED int __pyx_7genexpr__pyx_v_i;\n",
+       "  long __pyx_8genexpr1__pyx_v_j;\n",
+       "  int __pyx_8genexpr2__pyx_v_i;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.importance_sampling_simulations_2dim_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XDECREF(__pyx_v_rng);\n",
+       "  __Pyx_XDECREF(__pyx_v_results);\n",
+       "  __Pyx_XDECREF(__pyx_v_ts);\n",
+       "  __Pyx_XDECREF(__pyx_v_ws);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "/* Python wrapper */\n",
+       "static PyObject *__pyx_pw_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyMethodDef __pyx_mdef_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise = {\"importance_sampling_simulations_2dim_1d_noise\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
+       "static PyObject *__pyx_pw_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       ") {\n",
+       "  double __pyx_v_x_in;\n",
+       "  double __pyx_v_y_in;\n",
+       "  double __pyx_v_t_in;\n",
+       "  double __pyx_v_t_f;\n",
+       "  double __pyx_v_dt;\n",
+       "  int __pyx_v_num_runs;\n",
+       "  double __pyx_v_bias_amp;\n",
+       "  double __pyx_v_phi_end_in;\n",
+       "  PyObject *__pyx_v_noise_list = 0;\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  CYTHON_UNUSED Py_ssize_t __pyx_nargs;\n",
+       "  #endif\n",
+       "  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;\n",
+       "  PyObject *__pyx_r = 0;\n",
+       "  __Pyx_RefNannyDeclarations\n",
+       "  __Pyx_RefNannySetupContext(\"importance_sampling_simulations_2dim_1d_noise (wrapper)\", 0);\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  #if CYTHON_ASSUME_SAFE_MACROS\n",
+       "  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);\n",
+       "  #else\n",
+       "  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;\n",
+       "  #endif\n",
+       "  #endif\n",
+       "  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);\n",
+       "  {\n",
+       "    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_in,&__pyx_n_s_y_in,&__pyx_n_s_t_in,&__pyx_n_s_t_f,&__pyx_n_s_dt,&__pyx_n_s_num_runs,&__pyx_n_s_bias_amp,&__pyx_n_s_phi_end_in,&__pyx_n_s_noise_list,0};\n",
+       "  PyObject* values[9] = {0,0,0,0,0,0,0,0,0};\n",
+       "    if (__pyx_kwds) {\n",
+       "      Py_ssize_t kw_args;\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  0: break;\n",
+       "        default: goto __pyx_L5_argtuple_error;\n",
+       "      }\n",
+       "      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  0:\n",
+       "        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_x_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else goto __pyx_L5_argtuple_error;\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1:\n",
+       "        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_y_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 1); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2:\n",
+       "        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 2); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3:\n",
+       "        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_f)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 3); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4:\n",
+       "        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dt)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 4); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5:\n",
+       "        if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_num_runs)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[5]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 5); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6:\n",
+       "        if (likely((values[6] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bias_amp)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[6]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 6); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7:\n",
+       "        if (likely((values[7] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_phi_end_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[7]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 7); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8:\n",
+       "        if (likely((values[8] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_noise_list)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[8]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 8); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "      }\n",
+       "      if (unlikely(kw_args > 0)) {\n",
+       "        const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
+       "        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"importance_sampling_simulations_2dim_1d_noise\") < 0)) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "      }\n",
+       "    } else if (unlikely(__pyx_nargs != 9)) {\n",
+       "      goto __pyx_L5_argtuple_error;\n",
+       "    } else {\n",
+       "      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "      values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "      values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "      values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "      values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "    }\n",
+       "    __pyx_v_x_in = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "    __pyx_v_y_in = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_y_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "    __pyx_v_t_in = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_t_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "    __pyx_v_t_f = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_t_f == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "    __pyx_v_dt = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_dt == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)\n",
+       "    __pyx_v_num_runs = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_num_runs == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)\n",
+       "    __pyx_v_bias_amp = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_bias_amp == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)\n",
+       "    __pyx_v_phi_end_in = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_phi_end_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)\n",
+       "    __pyx_v_noise_list = values[8];\n",
+       "  }\n",
+       "  goto __pyx_L6_skip;\n",
+       "  __pyx_L5_argtuple_error:;\n",
+       "  __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, __pyx_nargs); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "  __pyx_L6_skip:;\n",
+       "  goto __pyx_L4_argument_unpacking_done;\n",
+       "  __pyx_L3_error:;\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.importance_sampling_simulations_2dim_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return NULL;\n",
+       "  __pyx_L4_argument_unpacking_done:;\n",
+       "  __pyx_r = __pyx_pf_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_importance_sampling_simulations_2dim_1d_noise(__pyx_self, __pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list);\n",
+       "  int __pyx_lineno = 0;\n",
+       "  const char *__pyx_filename = NULL;\n",
+       "  int __pyx_clineno = 0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "static PyObject *__pyx_pf_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_importance_sampling_simulations_2dim_1d_noise(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list) {\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_importance_sampling_simulations_2dim_1d_noise(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.importance_sampling_simulations_2dim_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = NULL;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "/* … */\n",
+       "  __pyx_tuple__22 = PyTuple_Pack(9, __pyx_n_s_x_in, __pyx_n_s_y_in, __pyx_n_s_t_in, __pyx_n_s_t_f, __pyx_n_s_dt, __pyx_n_s_num_runs, __pyx_n_s_bias_amp, __pyx_n_s_phi_end_in, __pyx_n_s_noise_list); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 112, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__22);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__22);\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise, 0, __pyx_n_s_importance_sampling_simulations, NULL, __pyx_n_s_cython_magic_21d3025fd53758f49a, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_importance_sampling_simulations, __pyx_t_7) < 0) __PYX_ERR(0, 112, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 113:                                            double dt, int num_runs, double bias_amp, double phi_end_in,
\n", + "
 114:                                                 noise_list):
\n", + "
 115:     # As this variable is global, I can just redfine it hear
\n", + "
+116:     rng = np.random.default_rng()
\n", + "
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_default_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "  __pyx_t_3 = NULL;\n",
+       "  __pyx_t_4 = 0;\n",
+       "  #if CYTHON_UNPACK_METHODS\n",
+       "  if (likely(PyMethod_Check(__pyx_t_2))) {\n",
+       "    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);\n",
+       "    if (likely(__pyx_t_3)) {\n",
+       "      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      __Pyx_INCREF(function);\n",
+       "      __Pyx_DECREF_SET(__pyx_t_2, function);\n",
+       "      __pyx_t_4 = 1;\n",
+       "    }\n",
+       "  }\n",
+       "  #endif\n",
+       "  {\n",
+       "    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};\n",
+       "    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);\n",
+       "    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  }\n",
+       "  __pyx_v_rng = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "
 117:     results =\\
\n", + "
+118:         [simulation_diff_general_end(x_in, y_in, t_in, t_f, dt, bias_amp, phi_end_in, noise_list, rng)\\
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "/* … */\n",
+       "      __pyx_t_2 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_simulation_diff_general_end(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, __pyx_v_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 118, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  __pyx_v_results = ((PyObject*)__pyx_t_1);\n",
+       "  __pyx_t_1 = 0;\n",
+       "
+119:          for i in range(num_runs)]
\n", + "
    __pyx_t_4 = __pyx_v_num_runs;\n",
+       "    __pyx_t_5 = __pyx_t_4;\n",
+       "    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "      __pyx_7genexpr__pyx_v_i = __pyx_t_6;\n",
+       "
 120:
\n", + "
 121:
\n", + "
+122:     ts, ws = [[results[i][j] for i in range(num_runs)] for j in range(2)]
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    for (__pyx_t_7 = 0; __pyx_t_7 < 2; __pyx_t_7+=1) {\n",
+       "      __pyx_8genexpr1__pyx_v_j = __pyx_t_7;\n",
+       "      { /* enter inner scope */\n",
+       "        __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "        __Pyx_GOTREF(__pyx_t_2);\n",
+       "        __pyx_t_4 = __pyx_v_num_runs;\n",
+       "        __pyx_t_5 = __pyx_t_4;\n",
+       "        for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "          __pyx_8genexpr2__pyx_v_i = __pyx_t_6;\n",
+       "          __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_results, __pyx_8genexpr2__pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_3);\n",
+       "          __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, __pyx_8genexpr1__pyx_v_j, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_8);\n",
+       "          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "          if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;\n",
+       "        }\n",
+       "      } /* exit inner scope */\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  if (1) {\n",
+       "    PyObject* sequence = __pyx_t_1;\n",
+       "    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "    if (unlikely(size != 2)) {\n",
+       "      if (size > 2) __Pyx_RaiseTooManyValuesError(2);\n",
+       "      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "      __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "    }\n",
+       "    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "    __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "    __pyx_t_8 = PyList_GET_ITEM(sequence, 1); \n",
+       "    __Pyx_INCREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_t_8);\n",
+       "    #else\n",
+       "    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_8);\n",
+       "    #endif\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  }\n",
+       "  __pyx_v_ts = __pyx_t_2;\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_v_ws = __pyx_t_8;\n",
+       "  __pyx_t_8 = 0;\n",
+       "
+123:     return ts, ws
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __Pyx_INCREF(__pyx_v_ts);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ts);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_ts)) __PYX_ERR(0, 123, __pyx_L1_error);\n",
+       "  __Pyx_INCREF(__pyx_v_ws);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ws);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ws)) __PYX_ERR(0, 123, __pyx_L1_error);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%cython -a\n", + "\n", + "import numpy as np\n", + "\n", + "cdef double e = 2.718281828459045\n", + "cdef double pi_const = 3.141592653589793\n", + "cdef double phi_star = 1.0\n", + "cdef double A_plus = 1e-14\n", + "cdef double A_minus = 1e-17\n", + "cdef double V_0 = 2.871906714642027e-12\n", + "cdef double diff_const = 1.5572025557368665e-07\n", + "cdef double phi_old\n", + "\n", + "\n", + "cdef double V_prime_by_V_cython(double phi):\n", + " if phi > phi_star:\n", + " return A_plus/(V_0 + A_plus*(phi - phi_star))\n", + " elif phi <= phi_star:\n", + " return A_minus/(V_0 + A_minus*(phi - phi_star))\n", + " \n", + "cdef int end_cond(double phi, double pi, double N, double phi_end):\n", + " if phi0: #Need to include the chance the noise is zero\n", + " pi =\\\n", + " pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN +\\\n", + " bias_amp*noise[1]*dN + noise[1]*dW[0]\n", + "\n", + " # Use the standard form for the weight calculation\n", + " A += bias_amp*(0.5*bias_amp*dN + dW[0])\n", + " else:\n", + " pi =\\\n", + " pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN\n", + " # No change as no noise is applied.\n", + " A += 0.\n", + "\n", + " return [phi, pi, A]\n", + "\n", + "\n", + "#A let's us calculate the bias w=e^-A is the bias, which propagated along with \n", + "#the importance sample path.\n", + "#See Eq. (33) of arXiv:nucl-th/9809075v1 for more info\n", + "cdef list simulation_diff_general_end(double x_in, double y_in, double t_in,\\\n", + " double t_f, double dt, double bias_amp, double phi_end_in, noise_list, rng):\n", + " cdef double t, sqrt_dt, x, y, z, A\n", + " cdef int i = 0\n", + " cdef int end_cond_value\n", + " cdef int len_rand_nums = 1000\n", + " cdef int reduced_step = 0\n", + " cdef int num_steps = 0\n", + " \n", + " cdef double [:, :] rand_nums\n", + " cdef double [:] dW\n", + " cdef double [:] noise\n", + "\n", + " t = t_in\n", + " x = x_in\n", + " y = y_in\n", + " sqrt_dt = dt**0.5\n", + " A = 0.0\n", + " rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))\n", + " dW = rand_nums[:, 0]\n", + " noise = noise_list[:, 0]\n", + "\n", + " while t" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.errorbar(bin_centres_2D, heights_2D, yerr=errors_2D, fmt=\".\", ms=7, label=\"2D, $\\sigma=$\"+str(sigma),\n", + " color=color[0])\n", + "plt.plot(bin_centres_2D, gaussian_pdf(bin_centres_2D), color=\"k\",\n", + " label=\"Gaussian\")\n", + "\n", + "# Now let's process and plot the 1D data\n", + "for j in range(len(sigma_values)):\n", + " sigma = sigma_values[j]\n", + " if sigma == 1.0:\n", + " raw_data = pd.read_csv(\"IS_data_x_in_1.0_iterations_100000_bias_0.0_sigma_1.0_A_log_ration_-3.0\"+\n", + " \"scale_exited26.05102_1D_bessel.csv\", index_col=0)\n", + " else:\n", + " raw_data = pd.read_csv(\"IS_data_x_in_0.999_iterations_100000_bias_0.0_sigma_\"+str(sigma)+\n", + " \"_A_log_ration_-3.0scale_exited26.05102_1D_bessel.csv\", index_col=0)\n", + "\n", + " # Easier to work with NumPy arrays\n", + " Ns = np.array(raw_data['FPTs'])\n", + "\n", + " bin_centres, heights, errors = fpt.numerics.re_processing(Ns, estimator=\"naive\", min_bin_size=100)\n", + " # Apply the delta N formula\n", + " bin_centres = np.array(bin_centres) - find_cg_time(k_end_scale_later, sigma, N_sim_end_later)\n", + "\n", + " plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7, label=\"1D, $\\sigma=$\"+str(sigma),\n", + " color=color[j+1])\n", + " \n", + "plt.yscale('log')\n", + "plt.legend(fontsize=18)\n", + "plt.xlabel(r'$\\delta \\mathcal{N}$')\n", + "plt.ylabel(r'$P(\\delta \\mathcal{N})$')\n", + "plt.title(r\"Piece-wise, $\\delta \\phi_{\\mathrm{h}}$\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clearly all of the data sets are consistent!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/User guides/Advanced/Piece_wise/Piece-wise linear potential 1- background plots and power spectrum.ipynb b/User guides/Advanced/Piece_wise/Piece-wise linear potential 1- background plots and power spectrum.ipynb new file mode 100644 index 0000000..39d2672 --- /dev/null +++ b/User guides/Advanced/Piece_wise/Piece-wise linear potential 1- background plots and power spectrum.ipynb @@ -0,0 +1,660 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Piece-wise linear potential 1 - background plots and power spectrum\n", + "\n", + "This is the first in a series of notebooks which will run importance sampling for the Piece-wise linear potential. It is commended the reading is familair with\n", + "- [Importance sampling](https://arxiv.org/abs/2206.11234).\n", + "- How to simulate the linear Sasaki-Mukhanov mode equation in inflation. \n", + "- The [PyFPT user guides](https://github.com/Jacks0nJ/PyFPT/tree/main/User%20guides).\n", + "\n", + "These Notebooks are simply meant to make all of the 2D results reproducible and are minimal in details.\n", + "\n", + "In this notebook the background dynamics will be simulated and the power spectrum found.\n", + "\n", + "Throughout natural units with $c = 8\\pi M_{\\rm PL} = \\hbar =1$ are used." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import mystyle\n", + "plt.style.use(mystyle.paper_style)\n", + "\n", + "from scipy.interpolate import CubicSpline\n", + "from scipy.integrate import odeint\n", + "from scipy.integrate import RK45\n", + "from scipy.optimize import root\n", + "from scipy.integrate import quad\n", + "from mpl_toolkits.axes_grid1.inset_locator import zoomed_inset_axes \n", + "from mpl_toolkits.axes_grid1.inset_locator import mark_inset\n", + "from timeit import default_timer as timer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The potential" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def potential(phi):\n", + " if phi > phi_star:\n", + " return V_0 + A_plus*(phi - phi_star)\n", + " elif phi <= phi_star:\n", + " return V_0 + A_minus*(phi - phi_star)\n", + "\n", + " \n", + "def potential_dif(phi):\n", + " if phi > phi_star:\n", + " return A_plus\n", + " elif phi <= phi_star:\n", + " return A_minus\n", + "\n", + "def potential_ddif(phi):\n", + " return 0.\n", + "\n", + "def V_prime_by_V(phi):\n", + " if phi > phi_star:\n", + " return A_plus/(V_0 + A_plus*(phi - phi_star))\n", + " elif phi <= phi_star:\n", + " return A_minus/(V_0 + A_minus*(phi - phi_star))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are shown such that the power spectrum peaks at $5 \\times 10^{-3}$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "pi_num = np.pi\n", + "\n", + "A_plus = 10**-14\n", + "A_minus = A_plus*(10**-3)\n", + "cmb_power_spectrum = 2*10**-9\n", + "V_0 = (12*cmb_power_spectrum*(pi_num*A_plus)**2)**(1/3)\n", + "H_0 = (V_0/3)**(1/2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Background simulation\n", + "Let's simulate background dynamics. Due to the transition, one either has to do a piece-wise simulation, or choose custom time steps. The later is done here." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Need to estimate the correct starting position to get $\\sim 20$ e-folds of slow roll before the transition." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.integrate import quad\n", + "from scipy.optimize import root\n", + "\n", + "# This equations assume slow-roll throughout\n", + "def slow_roll_N(phi_in, phi_end):\n", + " def integrand(phi):\n", + " return potential(phi)/potential_dif(phi)\n", + " N, _ = quad(integrand, phi_end, phi_in)\n", + " return N\n", + "\n", + "def root_find_phi_in(phi):\n", + " return slow_roll_N(phi, phi_star) - N_star\n", + "\n", + "phi_star = 1.\n", + "N_star = 26.\n", + "phi_in_guess = (A_plus/V_0)*N_star + phi_star\n", + "sol_root = root(root_find_phi_in, phi_in_guess)\n", + "phi_CMB_in = float(sol_root.x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now define the equation of motion" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def klien_gordon(vec, N):\n", + " phi, pi = vec\n", + " dpi_by_dN = -(3 - 0.5*pi**2)*(pi + V_prime_by_V(phi))\n", + " return [pi, dpi_by_dN]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use slow roll at NLO to set the initial conditions with maximum accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def hubble_param_LO_1(phi):\n", + " return 0.5*(potential_dif(phi)/potential(phi))**2\n", + "\n", + "def hubble_param_LO_2(phi):\n", + " return 2*( (potential_dif(phi)/potential(phi))**2\\\n", + " - potential_ddif(phi)/potential(phi) )\n", + "\n", + "def hubble_param_NLO_1(phi):\n", + " return hubble_param_LO_1(phi)*(1 - hubble_param_LO_2(phi)/3)\n", + "\n", + "def dpi_by_dN_NLO(phi):\n", + " return -(2*hubble_param_NLO_1(phi))**0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now simulate the background" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "N_values = np.linspace(0, N_star + 25, 800)\n", + "N_values_detailed = np.linspace(N_star-2, N_star+6, 200)\n", + "N_values_detailed = np.linspace(N_star-0.1, N_star+0.1, 50)\n", + "N_values = np.concatenate((N_values, N_values_detailed))\n", + "N_values = np.sort(N_values)\n", + "\n", + "phi_0 = phi_CMB_in\n", + "dpi_by_dN_0 = dpi_by_dN_NLO(phi_0)\n", + "initial_state = [phi_0, dpi_by_dN_0]\n", + "sol = odeint(klien_gordon, initial_state, N_values)\n", + "phi_values = sol[:, 0]\n", + "phi_diff_values = sol[:, 1]\n", + "phi_end_true = sol[-1, 0]\n", + "N_end = N_values[-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have the general sim, now let's find when it should end and re-simulate, ending at that value." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def hubble_param_1_func(dpi_by_dN):\n", + " return (dpi_by_dN**2)/2 \n", + "\n", + "def hubble_func(phi, pi):\n", + " H_squared = 2*potential(phi)/(6-pi**2)\n", + " return H_squared**0.5\n", + "\n", + "def hubble_param_2_func(phi, pi):\n", + " epsilon_H = hubble_param_1_func(pi)\n", + " V_prime_by_V_value = V_prime_by_V(phi)\n", + " return 2*epsilon_H - V_prime_by_V_value*(6-pi**2)/pi - 6" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def nu_sqaured_func(N):\n", + " epsilon2 = epsilon2_interpolation(N, 0)\n", + " epsilon1 = epsilon1_interpolation(N, 0)\n", + " epsilon2_derivative = epsilon2_interpolation(N, 1)\n", + " return 9/4 - epsilon1 + (3/2)*epsilon2 - (1/2)*epsilon1*epsilon2 + (epsilon2**2)/4\\\n", + " + epsilon2_derivative/2" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "hubble_param_values = np.array([hubble_func(sol[i, 0], sol[i, 1]) for i in range(len(sol[:, 0]))])\n", + "epsilon1_values = np.array([hubble_param_1_func(dpi_by_dN) for dpi_by_dN in sol[:, 1]])\n", + "epsilon2_values = np.array([hubble_param_2_func(sol[i, 0], sol[i, 1]) for i in range(len(sol[:, 0]))])\n", + "\n", + "# interpolation\n", + "hubble_param_interpolation = CubicSpline(N_values, hubble_param_values)\n", + "epsilon1_interpolation = CubicSpline(N_values, epsilon1_values)\n", + "epsilon2_interpolation = CubicSpline(N_values, epsilon2_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "nu_squared_values = np.array([nu_sqaured_func(N_values[i]) for i in range(len(N_values))])\n", + "\n", + "nu_squared_interpolation = CubicSpline(N_values, nu_squared_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "N_for_plotting_logic = (N_values>15) & (N_values<35)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's plot what the Hubble flow parameters and $\\nu^2$ is doing" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_values[N_for_plotting_logic], np.log10(epsilon1_values[N_for_plotting_logic]),\n", + " label=r\"$\\log_{10}{(\\epsilon_{1})}$\")\n", + "plt.plot(N_values[N_for_plotting_logic], epsilon2_values[N_for_plotting_logic], label=r\"$\\epsilon_{2}$\")\n", + "plt.plot(N_values[N_for_plotting_logic], nu_squared_values[N_for_plotting_logic], label=r\"$\\nu^2$\")\n", + "plt.xlabel(r\"$N$\")\n", + "plt.ylim(top=8, bottom=-13)\n", + "plt.legend(ncol=2)\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**This is just for mostly demonstration. We will often use analytical expressions for the above curves for accuracy**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While there is clearly a period of ultra-slow roll, what is its precise duration? Let's find out using standard root-finding techniques and interpolation." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def root_finding_epsilon2(N_guess, epsilon2_chosen=-3):\n", + " def epsilon2_value_diff(N_epsilon2_time):\n", + " return epsilon2_interpolation(N_epsilon2_time) - epsilon2_chosen\n", + " sol_epsilon2_time = root(epsilon2_value_diff, N_guess)\n", + " N_epsilon2_time = sol_epsilon2_time.x\n", + " return float(N_epsilon2_time)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ultra-slow roll started at\n", + "26.000001745817695\n", + "and ended at\n", + "28.302282891541452\n" + ] + } + ], + "source": [ + "N_usr_start_guess = N_values[epsilon2_values<-3][0]\n", + "N_usr_end_guess = N_values[epsilon2_values<-3][-1]\n", + "\n", + "N_usr_start = root_finding_epsilon2(N_usr_start_guess)\n", + "N_usr_end = root_finding_epsilon2(N_usr_end_guess)\n", + "\n", + "print(\"Ultra-slow roll started at\")\n", + "print(N_usr_start)\n", + "print(\"and ended at\")\n", + "print(N_usr_end)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now let's save this " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "data_dict = {}\n", + "data_dict[\"N\"] = N_values\n", + "data_dict[\"phi\"] = phi_values\n", + "data_dict[\"phi_N_diff\"] = phi_diff_values\n", + "data_dict[\"H\"] = hubble_param_values\n", + "data_dict[\"epsilon1\"] = epsilon1_values\n", + "data_dict[\"epsilon2\"] = epsilon2_values\n", + "data_dict[\"nu_squared\"] = nu_squared_values\n", + "\n", + "data_pandas = pd.DataFrame(data_dict)\n", + "\n", + "data_pandas.to_csv(\"piece_wise_linear_dynamics_dynamics\"+\".csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mode simulation\n", + "\n", + "To find the power spectrum, normally we need to be able to simulare a linear mode from deep inside the horizon until Hubble-crossing until the end of inflation. But due to the analytical nature of this model, we can solve the mode equation analoytically. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def comoving_time_func(N_interest, N_end):\n", + " def comoving_time_integrand(N):\n", + " aH = aH_interpolation(N)\n", + " return 1/aH\n", + " comoving_time_value, _ = quad(comoving_time_integrand, N_end, N_interest, limit=1000)\n", + " return comoving_time_value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## $\\delta \\phi_k$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def analytical_delta_phi(N_interest, N_end, N_transition, A_plus, A_minus, k):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_0 = aH_interpolation(N_transition)\n", + " a = a_interpolation(N_interest)\n", + " H0 = hubble_param_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " Delta_A = A_minus - A_plus\n", + " k_eta = k*comoving_time\n", + "\n", + " if N_interest>N_transition:\n", + " alpha = 1. + complex(0, 1)*(3*Delta_A*k_0/(2*A_plus*k))*(1 + (k_0/k)**2)\n", + " beta = complex(0, -1)*(3*Delta_A*k_0/(2*A_plus*k))*np.exp(complex(0, 2*k/k_0))*(complex(1, k_0/k)**2)\n", + " else:\n", + " alpha = 1.\n", + " beta = 0.\n", + "\n", + " term1 = complex(1, k_eta)*np.exp(complex(0, -k_eta))\n", + " term2 = complex(1, -k_eta)*np.exp(complex(0, k_eta))\n", + " k_term = complex(0, H0/(2*k**3)**0.5)\n", + "\n", + " delta_phi = k_term*(alpha*term1 - beta*term2)\n", + " return delta_phi\n", + "\n", + "def analytical_delta_phi_N_derivative(N_interest, N_end, N_transition, A_plus, A_minus, k):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_0 = aH_interpolation(N_transition)\n", + " a = a_interpolation(N_interest)\n", + " H0 = hubble_param_interpolation(N_interest)\n", + " epsilon = epsilon_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " Delta_A = A_minus - A_plus\n", + " k_eta = k*comoving_time\n", + "\n", + " if N_interest>N_transition:\n", + " alpha = 1. + complex(0, 1)*(3*Delta_A*k_0/(2*A_plus*k))*(1 + (k_0/k)**2)\n", + " beta = complex(0, -1)*(3*Delta_A*k_0/(2*A_plus*k))*np.exp(complex(0, 2*k/k_0))*(complex(1, k_0/k)**2)\n", + " else:\n", + " alpha = 1.\n", + " beta = 0.\n", + "\n", + " term1_deriv = (k**2)*comoving_time*np.exp(complex(0, -k_eta))\n", + " term2_deriv = (k**2)*comoving_time*np.exp(complex(0, k_eta))\n", + " k_term = complex(0, H0/(2*k**3)**0.5)\n", + "\n", + "\n", + " delta_phi_N_derivative = k_term*(alpha*term1_deriv - beta*term2_deriv)/aH\n", + " return delta_phi_N_derivative" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In fact it is more accurate to use the analytical expressions" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def analytical_epsilon_1(N_interest, N_end, N_transition, A_plus, A_minus):\n", + " H = hubble_param_interpolation(N_interest)\n", + " if N_interest<=N_transition:\n", + " epsilon_1 = (A_plus**2)/(18*(H**4))\n", + " elif N_interest>N_transition:\n", + " Delta_A = A_minus - A_plus\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_transition = aH_interpolation(N_transition)\n", + " epsilon_1 = ((Delta_A*(comoving_time*k_transition)**3 + A_minus)**2)/(18*(H**4))\n", + " return epsilon_1\n", + "\n", + "def analytical_epsilon_2(N_interest, N_end, N_transition, A_plus, A_minus):\n", + " H = hubble_param_interpolation(N_interest)\n", + " if N_interest<=N_transition:\n", + " epsilon_2 = 0.\n", + " elif N_interest>N_transition:\n", + " Delta_A = A_minus - A_plus\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_transition = aH_interpolation(N_transition)\n", + " epsilon_2 =\\\n", + " (-6*Delta_A*(comoving_time*k_transition)**3)/(Delta_A*(comoving_time*k_transition)**3 + A_minus)\n", + " return epsilon_2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Power spectrum\n", + "Let us use the analytical formula to find the phase-space" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def power_spectrum_func(k, R):\n", + " return (np.abs(R)**2)*(k**3)/(2*np.pi**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "a_in = 1\n", + "N_values_for_plot = np.linspace(N_star - np.log(4*10**3), N_star + np.log(4*10**3), 1000)\n", + "N_eval = N_end-5 # This is to prevent a numerical accuracy error.\n", + "\n", + "power_specrum_values = np.zeros(len(N_values_for_plot))\n", + "for j in range(len(N_values_for_plot)):\n", + " N_mode_exit = N_values_for_plot[j]\n", + " # Find when this mode left the horizon\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " delta_phi = analytical_delta_phi(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " R = delta_phi/np.sqrt(2*analytical_epsilon_1(N_eval, N_end, N_star, A_plus, A_minus))\n", + " power_specrum_values[j] = power_spectrum_func(k, R)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_star))\n", + "\n", + "k_values_plot_normalised = aH_interpolation(N_values_for_plot)/aH_interpolation(N_star)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(k_values_plot_normalised, power_specrum_values)\n", + "plt.axvline(x=1, linestyle=\"dashed\", color=\"k\")\n", + "plt.axvline(x=1000, linestyle=\"dashed\", color=\"k\", label=\"Modes simulated\")\n", + "plt.axvline(x=aH_interpolation(N_usr_end)/aH_interpolation(N_star), linestyle=\"dotted\",\n", + " color=\"gray\", label=\"USR end\")\n", + "plt.yscale(\"log\")\n", + "plt.xscale(\"log\")\n", + "plt.xlim(left=0.5*10**-3, right=2*10**3)\n", + "plt.ylabel(r\"$\\mathcal{P}_\\mathcal{R}(k)$\")\n", + "plt.xlabel(r\"$k/k_{\\rm T}$\")\n", + "plt.legend()\n", + "plt.show()\n", + "plt.clf()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/User guides/Advanced/Piece_wise/Piece-wise linear potential 2 - noise modelling.ipynb b/User guides/Advanced/Piece_wise/Piece-wise linear potential 2 - noise modelling.ipynb new file mode 100644 index 0000000..60eb930 --- /dev/null +++ b/User guides/Advanced/Piece_wise/Piece-wise linear potential 2 - noise modelling.ipynb @@ -0,0 +1,1392 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Piece-wise linear potential 2 - noise modelling\n", + "\n", + "This is the second in a series of notebooks which will run importance sampling for the piece-wise linear potential. Familiarity with stochastic inflation and covariance matrices is assumed, see for example https://arxiv.org/pdf/2303.17375\n", + "\n", + "In this notebook we show how the different noise curves can be found using the background trajectory. We use the Bessel matching approach to find the homogeneous noise.\n", + "\n", + "Throughout natural units with $c = 8\\pi M_{\\rm PL} = \\hbar =1$ are used." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import mystyle\n", + "plt.style.use(mystyle.paper_style)\n", + "\n", + "# Need to make sure you have pyfpt installed\n", + "import pyfpt as fpt\n", + "from scipy.interpolate import CubicSpline\n", + "from scipy.integrate import odeint\n", + "from scipy.optimize import root\n", + "from scipy.integrate import quad\n", + "from timeit import default_timer as timer\n", + "\n", + "from matplotlib.patches import Ellipse\n", + "from matplotlib.lines import Line2D\n", + "from matplotlib import colormaps\n", + "import matplotlib.animation as animation\n", + "from matplotlib.animation import PillowWriter\n", + "from matplotlib import colors\n", + "from matplotlib import colorbar\n", + "\n", + "from mpmath import besselj as besselj_func\n", + "from mpmath import bessely as bessely_func\n", + "from mpmath import gamma as gamma_func" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Potential" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def potential(phi):\n", + " if phi > phi_star:\n", + " return V_0 + A_plus*(phi - phi_star)\n", + " elif phi <= phi_star:\n", + " return V_0 + A_minus*(phi - phi_star)\n", + "\n", + " \n", + "def potential_dif(phi):\n", + " if phi > phi_star:\n", + " return A_plus\n", + " elif phi <= phi_star:\n", + " return A_minus\n", + "\n", + "def potential_ddif(phi):\n", + " return 0.\n", + "\n", + "def V_prime_by_V(phi):\n", + " if phi > phi_star:\n", + " return A_plus/(V_0 + A_plus*(phi - phi_star))\n", + " elif phi <= phi_star:\n", + " return A_minus/(V_0 + A_minus*(phi - phi_star))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are shown such that the power spectrum peaks at $5 \\times 10^{-3}$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "pi_num = np.pi\n", + "\n", + "A_plus = 10**-14\n", + "A_minus = A_plus*(10**-3)\n", + "cmb_power_spectrum = 2*10**-9\n", + "V_0 = (12*cmb_power_spectrum*(pi_num*A_plus)**2)**(1/3)\n", + "H_0 = (V_0/3)**(1/2)\n", + "N_star = 26.\n", + "phi_star = 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading in background" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "background_data = pd.read_csv(\"piece_wise_linear_dynamics_dynamics\"+\".csv\", index_col=0)\n", + "\n", + "N_values = np.array(background_data[\"N\"])\n", + "phi_values = np.array(background_data[\"phi\"])\n", + "phi_diff_values = np.array(background_data[\"phi_N_diff\"])\n", + "hubble_param_values = np.array(background_data[\"H\"])\n", + "epsilon1_values = np.array(background_data[\"epsilon1\"])\n", + "epsilon2_values = np.array(background_data[\"epsilon2\"])\n", + "nu_squared_values = np.array(background_data[\"nu_squared\"])\n", + "\n", + "N_end = N_values[-1]\n", + "phi_end_true = phi_values[-1]\n", + "a_in = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "hubble_param_interpolation = CubicSpline(N_values, hubble_param_values)\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_star))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Updating the interpolation which are senstive to any errors to use the analytical versions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def comoving_time_func(N_interest, N_end):\n", + " def comoving_time_integrand(N):\n", + " aH = aH_interpolation(N)\n", + " return 1/aH\n", + " comoving_time_value, _ = quad(comoving_time_integrand, N_end, N_interest, limit=1000)\n", + " return comoving_time_value\n", + "\n", + "def analytical_epsilon_1(N_interest, N_end, N_transition, A_plus, A_minus):\n", + " H = hubble_param_interpolation(N_interest)\n", + " if N_interest<=N_transition:\n", + " epsilon_1 = (A_plus**2)/(18*(H**4))\n", + " elif N_interest>N_transition:\n", + " Delta_A = A_minus - A_plus\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_transition = aH_interpolation(N_transition)\n", + " epsilon_1 = ((Delta_A*(comoving_time*k_transition)**3 + A_minus)**2)/(18*(H**4))\n", + " return epsilon_1\n", + "\n", + "def analytical_epsilon_2(N_interest, N_end, N_transition, A_plus, A_minus):\n", + " H = hubble_param_interpolation(N_interest)\n", + " if N_interest<=N_transition:\n", + " epsilon_2 = 0.\n", + " elif N_interest>N_transition:\n", + " Delta_A = A_minus - A_plus\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_transition = aH_interpolation(N_transition)\n", + " epsilon_2 =\\\n", + " (-6*Delta_A*(comoving_time*k_transition)**3)/(Delta_A*(comoving_time*k_transition)**3 + A_minus)\n", + " return epsilon_2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "epsilon1_values = np.array([analytical_epsilon_1(N_values[i], N_end, N_star, A_plus, A_minus) for i in range(len(N_values))])\n", + "epsilon2_values = np.array([analytical_epsilon_2(N_values[i], N_end, N_star, A_plus, A_minus) for i in range(len(N_values))])\n", + "\n", + "# interpolation\n", + "epsilon1_interpolation = CubicSpline(N_values, epsilon1_values)\n", + "epsilon2_interpolation = CubicSpline(N_values, epsilon2_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def nu_sqaured_func(N):\n", + " epsilon2 = epsilon2_interpolation(N, 0)\n", + " epsilon1 = epsilon1_interpolation(N, 0)\n", + " epsilon2_derivative = epsilon2_interpolation(N, 1)\n", + " return 9/4 - epsilon1 + (3/2)*epsilon2 - (1/2)*epsilon1*epsilon2 + (epsilon2**2)/4\\\n", + " + epsilon2_derivative/2" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "nu_squared_values = np.array([nu_sqaured_func(N_values[i]) for i in range(len(N_values))])\n", + "\n", + "nu_squared_interpolation = CubicSpline(N_values, nu_squared_values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## $\\delta \\phi_k$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def analytical_delta_phi(N_interest, N_end, N_transition, A_plus, A_minus, k):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_0 = aH_interpolation(N_transition)\n", + " a = a_interpolation(N_interest)\n", + " H0 = hubble_param_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " Delta_A = A_minus - A_plus\n", + " k_eta = k*comoving_time\n", + "\n", + " if N_interest>N_transition:\n", + " alpha = 1. + complex(0, 1)*(3*Delta_A*k_0/(2*A_plus*k))*(1 + (k_0/k)**2)\n", + " beta = complex(0, -1)*(3*Delta_A*k_0/(2*A_plus*k))*np.exp(complex(0, 2*k/k_0))*(complex(1, k_0/k)**2)\n", + " else:\n", + " alpha = 1.\n", + " beta = 0.\n", + "\n", + " term1 = complex(1, k_eta)*np.exp(complex(0, -k_eta))\n", + " term2 = complex(1, -k_eta)*np.exp(complex(0, k_eta))\n", + " k_term = complex(0, H0/(2*k**3)**0.5)\n", + "\n", + " delta_phi = k_term*(alpha*term1 - beta*term2)\n", + " return delta_phi\n", + "\n", + "def analytical_delta_phi_N_derivative(N_interest, N_end, N_transition, A_plus, A_minus, k):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_0 = aH_interpolation(N_transition)\n", + " a = a_interpolation(N_interest)\n", + " H0 = hubble_param_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " Delta_A = A_minus - A_plus\n", + " k_eta = k*comoving_time\n", + "\n", + " if N_interest>N_transition:\n", + " alpha = 1. + complex(0, 1)*(3*Delta_A*k_0/(2*A_plus*k))*(1 + (k_0/k)**2)\n", + " beta = complex(0, -1)*(3*Delta_A*k_0/(2*A_plus*k))*np.exp(complex(0, 2*k/k_0))*(complex(1, k_0/k)**2)\n", + " else:\n", + " alpha = 1.\n", + " beta = 0.\n", + "\n", + " term1_deriv = (k**2)*comoving_time*np.exp(complex(0, -k_eta))\n", + " term2_deriv = (k**2)*comoving_time*np.exp(complex(0, k_eta))\n", + " k_term = complex(0, H0/(2*k**3)**0.5)\n", + "\n", + "\n", + " delta_phi_N_derivative = k_term*(alpha*term1_deriv - beta*term2_deriv)/aH\n", + " return delta_phi_N_derivative" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## $\\delta \\phi_{\\rm h}$" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def analytical_delta_phi_homo(N_interest, N_end, N_transition, A_plus, A_minus, k, just_growing=False):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_0 = aH_interpolation(N_transition)\n", + " a = a_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " H = hubble_param_interpolation(N_interest)\n", + " Delta_A = A_minus - A_plus\n", + "\n", + " if N_interest>N_transition:\n", + " alpha = 1. + complex(0, 1)*(3*Delta_A*k_0/(2*A_plus*k))*(1 + (k_0/k)**2)\n", + " beta = complex(0, -1)*(3*Delta_A*k_0/(2*A_plus*k))*np.exp(complex(0, 2*k/k_0))*(complex(1, k_0/k)**2)\n", + " else:\n", + " alpha = 1.\n", + " beta = 0.\n", + " prefactor = complex(0, H/(np.sqrt(2*k**3)))\n", + " growing = alpha-beta\n", + " if just_growing==True:\n", + " decaying = 0.\n", + " else:\n", + " decaying = complex(0, -1/3)*(alpha + beta)*(k*comoving_time)**3\n", + "\n", + " return prefactor*(growing + decaying)\n", + "\n", + "# My formula\n", + "def analytical_delta_phi_N_derivative_homo(N_interest, N_end, N_transition, A_plus, A_minus, k,\n", + " just_growing=False):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_0 = aH_interpolation(N_transition)\n", + " a = a_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " H = hubble_param_interpolation(N_interest)\n", + " Delta_A = A_minus - A_plus\n", + " k_eta = k*comoving_time\n", + "\n", + " if N_interest>N_transition:\n", + " alpha = 1. + complex(0, 1)*(3*Delta_A*k_0/(2*A_plus*k))*(1 + (k_0/k)**2)\n", + " beta = complex(0, -1)*(3*Delta_A*k_0/(2*A_plus*k))*np.exp(complex(0, 2*k/k_0))*(complex(1, k_0/k)**2)\n", + " else:\n", + " alpha = 1.\n", + " beta = 0.\n", + " \n", + " prefactor = complex(0, H/(np.sqrt(2*k**3)))\n", + " growing = 0.\n", + " if just_growing==True:\n", + " decaying = 0.\n", + " else:\n", + " decaying = complex(0, -1)*(alpha + beta)*(k**3)*(comoving_time**2)\n", + " # remember the factor of aH coming from d tau / dN\n", + " return prefactor*(growing + decaying)/aH" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Noise modelling\n", + "We find the noise using the values of $\\delta \\phi$ for the noise analytically." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def find_cg_time(k, sigma, N_exit):\n", + " def exit_time_func(N_cg_exit):\n", + " return k - sigma*aH_interpolation(N_cg_exit)\n", + " N_guess = N_exit + np.log(sigma**-1)\n", + " sol_cg_time = root(exit_time_func, N_guess)\n", + " N_cg_exit = sol_cg_time.x\n", + " return float(N_cg_exit)\n", + "\n", + "def find_exit_time(sigma, N_cg):\n", + " def exit_time_func(N_exit):\n", + " return sigma*aH_interpolation(N_cg)-aH_interpolation(N_exit)\n", + " N_guess = N_cg + np.log(sigma)\n", + " sol_exit_time = root(exit_time_func, N_guess)\n", + " N_exit = sol_exit_time.x\n", + " return float(N_exit)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def correlation_matrix(delta_phi, delta_phi_derivative, k_sigma, epsilon1):\n", + " overall_amplitude = (1/(2*np.pi**2))*(1-epsilon1)*k_sigma**3\n", + "\n", + " phi_noise = overall_amplitude*np.abs(delta_phi)**2\n", + " pi_noise = overall_amplitude*np.abs(delta_phi_derivative)**2\n", + " # To make sure the complex conjugate can be calculated\n", + " delta_phi_normed = delta_phi/np.abs(delta_phi)\n", + " delta_phi_diff_conj_normed = np.conjugate(delta_phi_derivative)/np.abs(delta_phi)\n", + " correlation = overall_amplitude*(delta_phi_normed*delta_phi_diff_conj_normed)\n", + " # Need to then multiple by this overall amplitude\n", + " correlation = correlation*np.abs(delta_phi)**2\n", + " return np.array([phi_noise, correlation, np.conjugate(correlation), pi_noise])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us begin with direct coarse graining the noise. We can do this semi-analytically using the analytical mode solution. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "phi_post_transition = phi_values[N_values>N_star]\n", + "phi_deriv_post_transition = phi_values[N_values>N_star]\n", + "N_values_post_transition = N_values[N_values>N_star]\n", + "\n", + "phi_in_post = phi_post_transition[0]\n", + "phi_deriv_in_post = phi_deriv_post_transition[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "diff_const = H_0/(2*np.pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "sigma = 0.01\n", + "\n", + "N_scale_exit = N_values_post_transition[0]\n", + "\n", + "# Rescale to this exit value\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_scale_exit))\n", + "k_in_scale = aH_interpolation(N_scale_exit)\n", + "k_transition = aH_interpolation(N_star)\n", + "\n", + "# Need to reset the normalisation, as it changes in the loop below\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_scale_exit))\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_scale_exit))\n", + "\n", + "# Need to find when this scale left the coarse-graining scale, and the corresponding field values\n", + "N_cg_exit = find_cg_time(k_in_scale, sigma, N_scale_exit)\n", + "\n", + "N_cg_values = np.arange(N_cg_exit, N_star+16, 0.001)\n", + "\n", + "# Now find the noise for these values\n", + "covaraince_matrix_array = np.zeros((3, len(N_cg_values)))\n", + "for i in range(len(N_cg_values)):\n", + " N_eval = N_cg_values[i]\n", + " # Find when this mode left the horizon\n", + " N_mode_exit = find_exit_time(sigma, N_eval)\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " delta_phi_at_sigma = analytical_delta_phi(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " delta_phi_deriv_at_sigma =\\\n", + " analytical_delta_phi_N_derivative(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covaraince_matrix = np.array([[covar_matrix[0], covar_matrix[1]], [covar_matrix[2], covar_matrix[3]]])\n", + " covaraince_matrix = covaraince_matrix.real\n", + " covaraince_matrix_array[0, i] = covaraince_matrix[0, 0]\n", + " covaraince_matrix_array[1, i] = covaraince_matrix[0, 1]\n", + " covaraince_matrix_array[2, i] = covaraince_matrix[1, 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values-N_star, covaraince_matrix_array[0, :],\n", + " label=r\"$\\Xi_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values-N_star, np.abs(covaraince_matrix_array[1, :]),\n", + " label=r\"$|\\Xi_{\\phi \\pi}|$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values-N_star, covaraince_matrix_array[2, :],\n", + " label=r\"$\\Xi_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$\\Xi_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}-N_{\\rm T}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Piece-wise linear, direct CG 2D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is behaving exactly as expected. \n", + "\n", + "If one is interesting in using this approach to find the noise, then you need to find the noise matrix, $S = \\Xi^2$, from the above. Let's do this using eigen decomposition." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "sigma = 0.01\n", + "\n", + "N_scale_exit = N_values_post_transition[0]\n", + "\n", + "# Rescale to this exit value\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_scale_exit))\n", + "k_in_scale = aH_interpolation(N_scale_exit)\n", + "k_transition = aH_interpolation(N_star)\n", + "\n", + "# Need to reset the normalisation, as it changes in the loop below\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_scale_exit))\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_scale_exit))\n", + "\n", + "# Need to find when this scale left the coarse-graining scale, and the corresponding field values\n", + "N_cg_exit = find_cg_time(k_in_scale, sigma, N_scale_exit)\n", + "\n", + "N_cg_values = np.arange(N_cg_exit, N_star+16, 0.001)\n", + "\n", + "# Now find the noise for these values\n", + "noise_matrix_array = np.zeros((3, len(N_cg_values)))\n", + "for i in range(len(N_cg_values)):\n", + " N_eval = N_cg_values[i]\n", + " # Find when this mode left the horizon\n", + " N_mode_exit = find_exit_time(sigma, N_eval)\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " delta_phi_at_sigma = analytical_delta_phi(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " delta_phi_deriv_at_sigma =\\\n", + " analytical_delta_phi_N_derivative(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covaraince_matrix = np.array([[covar_matrix[0], covar_matrix[1]], [covar_matrix[2], covar_matrix[3]]])\n", + " # Normalise to hopefully make the square root more accurate\n", + " covaraince_matrix = covaraince_matrix/(diff_const**2)\n", + " covaraince_matrix = covaraince_matrix.real\n", + " eigenvalues, eigenvectors = np.linalg.eig(covaraince_matrix)\n", + " # Find the inverse eigenvector for diagonalisation\n", + " eigenvectors_inverse = np.linalg.inv(eigenvectors)\n", + " # Now find the square root of the eigen value matrix\n", + " Lambda_root = np.asmatrix([[eigenvalues[0]**0.5, 0], [0, eigenvalues[1]**0.5]])\n", + " noise_matrix = eigenvectors*Lambda_root*eigenvectors_inverse\n", + " # As this is symmetric, let's convert it back into its usual form\n", + " noise_matrix_array[0, i] = noise_matrix[0, 0]\n", + " noise_matrix_array[1, i] = noise_matrix[0, 1]\n", + " noise_matrix_array[2, i] = noise_matrix[1, 1]\n", + "\n", + "# Rescale at the end\n", + "noise_matrix_array = noise_matrix_array*(diff_const)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values, noise_matrix_array[0, :],\n", + " label=r\"$S_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, np.abs(noise_matrix_array[1, :]),\n", + " label=r\"$|S_{\\phi \\pi}|$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, noise_matrix_array[2, :],\n", + " label=r\"$S_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$S_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above curves are the standard approach for finding the noise." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ellipse\n", + "Now let us show behaviour of the homogeneous mode. Specifically its super-Hubble squeezing after the transition." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "color = ['#377eb8', '#ff7f00', '#984ea3','#4daf4a', '#a65628', '#f781bf','#999999', '#e41a1c', '#dede00']" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = colormaps['plasma']\n", + "frames = 40\n", + "sigma_values = 10**np.linspace(-2.5, 0, frames)\n", + "sigma_values = np.flip(sigma_values)\n", + "colors_plasma = cmap(np.linspace(0, 1, frames))\n", + "cmap_color_bar = plt.get_cmap('plasma', frames) \n", + "norm_colors = colors.Normalize(vmin=-np.log10(sigma_values[0]), vmax=-np.log10(sigma_values[-1]))\n", + "\n", + "N_scale_exit = N_star + 0.1\n", + "\n", + "# Rescale to this exit value\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_scale_exit))\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_scale_exit))\n", + "k_in_scale = aH_interpolation(N_scale_exit)\n", + "k_transition = aH_interpolation(N_star)\n", + "\n", + "\n", + "fig, ax = plt.subplots(1)\n", + "ax.set_aspect('equal')\n", + "\n", + "def update(frame):\n", + " sigma = sigma_values[frame]\n", + "\n", + " N_eval = find_cg_time(k_in_scale, sigma, N_scale_exit)\n", + "\n", + " k = aH_interpolation(N_scale_exit)\n", + "\n", + " delta_phi_at_sigma = analytical_delta_phi_homo(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " delta_phi_deriv_at_sigma =\\\n", + " analytical_delta_phi_N_derivative_homo(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + "\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " # Normalise to hopefully keep everything to reasonable numbers\n", + " covaraince_matrix = np.array([[covar_matrix[0], covar_matrix[1]], [covar_matrix[2], covar_matrix[3]]])\n", + " covaraince_matrix = covaraince_matrix/(diff_const**2)\n", + " covaraince_matrix = covaraince_matrix.real\n", + " # Using Kazuya's code\n", + " S = covaraince_matrix\n", + " # Using Kazuya's code\n", + " S = covaraince_matrix\n", + " su2 = ((S[0, 0] + S[1, 1]) + np.sqrt((S[0, 0] - S[1, 1])**2 + 4*S[0, 1]**2)) / 2\n", + " sv2 = ((S[0, 0] + S[1, 1]) - np.sqrt((S[0, 0] - S[1, 1])**2 + 4*S[0, 1]**2)) / 2\n", + " slope1 = (su2 - S[0, 0]) / S[0, 1]\n", + " theta = np.arctan(slope1) * 180.0 / np.pi\n", + " m = np.array([0, 0])\n", + " a = np.sqrt(su2)\n", + " b = np.sqrt(sv2)\n", + " normalisation = (a*b)**0.5\n", + " a = a/normalisation\n", + " b = b/normalisation\n", + "\n", + " return ax.add_patch(Ellipse(m, 2*a, 2*b, angle=theta, color=colors_plasma[frame], fill=False, zorder=0))\n", + "\n", + "\n", + "sm = plt.cm.ScalarMappable(cmap=cmap_color_bar, norm=norm_colors) \n", + "sm.set_array([])\n", + "plt.colorbar(sm, ax=ax, label=r\"$- \\log_{10} (\\sigma)$\") \n", + "\n", + "# Drawing animation\n", + "ani = animation.FuncAnimation(fig=fig, func=update, frames=40, interval=30)\n", + "ax.set_title(r\"$N_{\\rm exit} - N_*$=\"+str(round(N_scale_exit-N_star, 3)))\n", + "plt.xlim(-2, 2)\n", + "plt.ylim(-2, 2)\n", + "ani.save(\"elipse_animation_N_exit_relative_\"+str(round(N_scale_exit-N_star, 3))+\".gif\", dpi=300,\n", + " writer=PillowWriter(fps=5))\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the squeezing is related to the eccentricity of the ellipse, this clearly shows the super-Hubble squeezing of the mode. A .gif file was also made, go check it out!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bessel matching\n", + "While for this analytical model we know what the [homogeneous mode is doing](https://arxiv.org/pdf/2311.03281), in general we don't for realistic models. Therefore we use this model as a test case for the Bessel matching approach, although here it is not needed." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def besselj_derivative_func(comoving_time, nu, k):\n", + " J_plus_1 = besselj_func(nu+1, -k*comoving_time)\n", + " J_minus_1 = besselj_func(nu-1, -k*comoving_time)\n", + " return (k/2)*(J_plus_1 - J_minus_1)\n", + "\n", + "def bessely_derivative_func(comoving_time, nu, k):\n", + " Y_plus_1 = bessely_func(nu+1, -k*comoving_time)\n", + " Y_minus_1 = bessely_func(nu-1, -k*comoving_time)\n", + " return (k/2)*(Y_plus_1 - Y_minus_1)\n", + "\n", + "def R_matching_to_Bessels(R, R_diff, N_interest, N_end, nu, k):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " epsilon1 = epsilon1_interpolation(N_interest)\n", + " epsilon2 = epsilon2_interpolation(N_interest)\n", + " a = a_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " z = (2*epsilon1*a**2)**0.5\n", + " z_prime_z = aH*(1 + 0.5*epsilon2)\n", + " extra_term = -(z_prime_z + 1/(-2*comoving_time))\n", + " besselj_value = besselj_func(nu, -k*comoving_time)\n", + " bessely_value = bessely_func(nu, -k*comoving_time)\n", + " besselj_diff_value = besselj_derivative_func(comoving_time, nu, k)\n", + " bessely_diff_value = bessely_derivative_func(comoving_time, nu, k)\n", + " # Need to convert to comoving time\n", + " R_prime = aH*R_diff\n", + " # Factor to change to R\n", + " prefactor = ((-comoving_time)**0.5)/z\n", + " # Now the different pre-factors needed to find A and B\n", + " c = prefactor*besselj_value\n", + " d = prefactor*bessely_value\n", + " e = prefactor*(extra_term*besselj_value + besselj_diff_value)\n", + " f = prefactor*(extra_term*bessely_value + bessely_diff_value)\n", + " # Now just need to solve standard system of simultanious equations\n", + " B = (c*R_prime - e*R)/(c*f - d*e)\n", + " A = (R - B*d)/c\n", + " return complex(A), complex(B)\n", + "\n", + "def homogeneous_Bessel_delta_phi(N_interest, N_end, nu, k, A, B, just_growing=False):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_comoving_time = -k*comoving_time\n", + " a = a_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " term1 = (A/gamma_func(nu+1) - B*gamma_func(-nu)*np.cos(nu*np.pi)/np.pi)*(0.5*k_comoving_time)**nu\n", + " term2 = (-B*gamma_func(nu)/np.pi)*(0.5*k_comoving_time)**-nu\n", + " if just_growing==True:\n", + " sasaki_mukanov = (term2)*(-comoving_time)**0.5\n", + " else:\n", + " sasaki_mukanov = (term1 + term2)*(-comoving_time)**0.5\n", + " delta_phi = sasaki_mukanov/a\n", + " return complex(delta_phi)\n", + "\n", + "def homogeneous_Bessel_delta_phi_N_derivative(N_interest, N_end, nu, k, A, B, just_growing=False):\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_comoving_time = -k*comoving_time\n", + " a = a_interpolation(N_interest)\n", + " aH = aH_interpolation(N_interest)\n", + " extra_term = (-aH + 0.5/comoving_time)\n", + " d = (-B*gamma_func(nu)/np.pi)\n", + " if just_growing==True:\n", + " # this is the coefficent of the decaying mde, so if we set it to zero we are neglecting it\n", + " c = 0.\n", + " else:\n", + " c = (A/gamma_func(nu+1) - B*gamma_func(-nu)*np.cos(nu*np.pi)/np.pi)\n", + " # This includes the 1/aH from changing to an N derivative, dN = aH d comoving time\n", + " prefactor = ((-comoving_time)**0.5)/(aH*a)\n", + " term_1 = extra_term*(c*(0.5*k_comoving_time)**(nu) + d*(0.5*k_comoving_time)**(-nu))\n", + " term_2 = 0.5*(nu*k)*(-c*(0.5*k_comoving_time)**(nu-1) + d*(0.5*k_comoving_time)**(-nu - 1))\n", + " delta_phi_homo_derivative = prefactor*(term_1 + term_2)\n", + " return complex(delta_phi_homo_derivative)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def R_from_delta_phi(N_interest, delta_phi, delta_phi_N_derivative):\n", + " epsilon1 = epsilon1_interpolation(N_interest)\n", + " # Remember previously there was a mistake here\n", + " return delta_phi/(2*epsilon1)**0.5\n", + "\n", + "def R_N_derivative_from_delta_phi(N_interest, delta_phi, delta_phi_N_derivative):\n", + " epsilon1 = epsilon1_interpolation(N_interest)\n", + " epsilon2 = epsilon2_interpolation(N_interest)\n", + " return (delta_phi_N_derivative - 0.5*epsilon2*delta_phi)/(2*epsilon1)**0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We should also evalute over the range and times for the simulations. The range used is over a scale of 1000 from the transition." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_star))\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_star))\n", + "\n", + "N_sim_end_estimate = N_star + np.log(10**3)\n", + "\n", + "sim_range_logic = (N_values>N_star+0.05) & (N_values" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Now we can run the simulation\n", + "plt.plot(N_cg_values, noise_matrix_array[0, :],\n", + " label=r\"$S_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, noise_matrix_array[1, :],\n", + " label=r\"$S_{\\phi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, noise_matrix_array[2, :],\n", + " label=r\"$S_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$S_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Piece-wise, $\\delta \\phi_{\\rm h}$, 2D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While the $\\pi$ noise is the same, the other two curves are quite different to the direct coarse-graining curves." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's save these noise curves for later use." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "data_dict = {}\n", + "data_dict[\"N\"] = N_cg_values\n", + "data_dict[\"phi-phi noise\"] = noise_matrix_array[0, :]\n", + "data_dict[\"phi-pi noise\"] = noise_matrix_array[1, :]\n", + "data_dict[\"pi-pi noise\"] = noise_matrix_array[2, :]\n", + "\n", + "data_pandas = pd.DataFrame(data_dict)\n", + "\n", + "data_pandas.to_csv(\"piece_wise_linear_noise_curves_Bessel_matched_sigma_\"+str(sigma)+\"_2D.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.821413838284229" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(N_cg_values)*dN" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1D noise\n", + "We can also find a 1D noise if the decaying mode is dropped. Let's find this for $\\sigma=0.01$ initially.\n", + "\n", + "The covariance matrix for 1D noise does not have a squareroot. So instead we just find the noise from the first element and the angle made by the noise in phase space" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "sigma = 0.01\n", + "\n", + "N_exit_values = np.arange(N_sim_start, N_sim_end, dN)\n", + "N_cg_values = np.zeros(len(N_exit_values))\n", + "\n", + "# Now find the noise for these values\n", + "noise_matrix_array = np.zeros((2, len(N_exit_values)))\n", + "for i in range(len(N_exit_values)):\n", + " N_mode_exit = N_exit_values[i]\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " # Find when this mode left the coarse-graining scale\n", + " N_eval = find_cg_time(k, sigma, N_mode_exit)\n", + " N_cg_values[i] = N_eval\n", + "\n", + " nu = complex(nu_squared_interpolation(N_eval), 0)**0.5\n", + " # First find the full version\n", + "\n", + " delta_phi_at_sigma = analytical_delta_phi(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " delta_phi_deriv_at_sigma =\\\n", + " analytical_delta_phi_N_derivative(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + "\n", + " # Then find the R from this\n", + " R_at_sigma = R_from_delta_phi(N_eval, delta_phi_at_sigma, delta_phi_deriv_at_sigma)\n", + " R_diff_at_sigma = R_N_derivative_from_delta_phi(N_eval, delta_phi_at_sigma, delta_phi_deriv_at_sigma)\n", + "\n", + " # We use these values to find the homogeneous behaviour\n", + " A, B = R_matching_to_Bessels(R_at_sigma, R_diff_at_sigma, N_eval, N_end, nu, k)\n", + " # Now we can find delta phi from these values\n", + " delta_phi_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " delta_phi_deriv_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi_N_derivative(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " tan_theta = np.real(delta_phi_deriv_at_sigma/delta_phi_at_sigma)\n", + "\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covaraince_matrix = np.array([[covar_matrix[0], covar_matrix[1]], [covar_matrix[2], covar_matrix[3]]])\n", + " covar_matrix = covar_matrix.real\n", + " # The phi noise is just the element square root, then pi noise is just this times the ratio\n", + " noise_matrix_array[0, i] = covar_matrix[0]**0.5\n", + " noise_matrix_array[1, i] = tan_theta*covar_matrix[0]**0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values, noise_matrix_array[0, :],\n", + " label=r\"$S_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, noise_matrix_array[1, :],\n", + " label=r\"$S_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$S_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Piece-wise, $\\delta \\phi_{\\rm h}$, 1D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also find the noise near Hubble exit." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "sigma = 1.\n", + "\n", + "N_exit_values = np.arange(N_sim_start, N_sim_end, dN)\n", + "N_cg_values = np.zeros(len(N_exit_values))\n", + "\n", + "# Now find the noise for these values\n", + "noise_matrix_array = np.zeros((2, len(N_exit_values)))\n", + "for i in range(len(N_exit_values)):\n", + " N_mode_exit = N_exit_values[i]\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " # Find when this mode left the coarse-graining scale\n", + " N_eval = find_cg_time(k, sigma, N_mode_exit)\n", + " N_cg_values[i] = N_eval\n", + "\n", + " nu = complex(nu_squared_interpolation(N_eval), 0)**0.5\n", + " # First find the full version\n", + "\n", + " delta_phi_at_sigma = analytical_delta_phi(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " delta_phi_deriv_at_sigma =\\\n", + " analytical_delta_phi_N_derivative(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + "\n", + " # Then find the R from this\n", + " R_at_sigma = R_from_delta_phi(N_eval, delta_phi_at_sigma, delta_phi_deriv_at_sigma)\n", + " R_diff_at_sigma = R_N_derivative_from_delta_phi(N_eval, delta_phi_at_sigma, delta_phi_deriv_at_sigma)\n", + "\n", + " # We use these values to find the homogeneous behaviour\n", + " A, B = R_matching_to_Bessels(R_at_sigma, R_diff_at_sigma, N_eval, N_end, nu, k)\n", + " # Now we can find delta phi from these values\n", + " delta_phi_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " delta_phi_deriv_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi_N_derivative(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " tan_theta = np.real(delta_phi_deriv_at_sigma/delta_phi_at_sigma)\n", + "\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covaraince_matrix = np.array([[covar_matrix[0], covar_matrix[1]], [covar_matrix[2], covar_matrix[3]]])\n", + " covar_matrix = covar_matrix.real\n", + " # The phi noise is just the element square root, then pi noise is just this times the ratio\n", + " noise_matrix_array[0, i] = covar_matrix[0]**0.5\n", + " noise_matrix_array[1, i] = tan_theta*covar_matrix[0]**0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(N_cg_values, noise_matrix_array[0, :],\n", + " label=r\"$S_{\\phi \\phi}$, $\\sigma=$\"+str(sigma))\n", + "plt.plot(N_cg_values, noise_matrix_array[1, :],\n", + " label=r\"$S_{\\pi \\pi}$, $\\sigma=$\"+str(sigma))\n", + "plt.yscale(\"log\")\n", + "plt.ylabel(r\"$S_{ij}$\")\n", + "plt.xlabel(r\"$N_{\\rm cg}$\")\n", + "plt.legend(ncol=2, fontsize=12)\n", + "plt.title(r\"Piece-wise, $\\delta \\phi_{\\rm h}$, 1D\")\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In both cases, the $\\pi$ noise is strongly sub-dominate, as expected when the decaying mode is dropped and the growing mode is just a constant." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can do the same for all of the different $\\sigma$ values, and save the different noise curves as we go." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "sigma_values = np.array([1.0, 0.5, 0.1, 0.01])\n", + "\n", + "for sigma_index in range(len(sigma_values)):\n", + " sigma = sigma_values[sigma_index]\n", + " N_exit_values = np.arange(N_sim_start, N_sim_end, dN)\n", + " N_cg_values = np.zeros(len(N_exit_values))\n", + "\n", + " # Now find the noise for these values\n", + " noise_matrix_array = np.zeros((2, len(N_exit_values)))\n", + " for i in range(len(N_exit_values)):\n", + " N_mode_exit = N_exit_values[i]\n", + "\n", + " aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_mode_exit))\n", + " a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_mode_exit))\n", + "\n", + " k = aH_interpolation(N_mode_exit)\n", + "\n", + " # Find when this mode left the coarse-graining scale\n", + " N_eval = find_cg_time(k, sigma, N_mode_exit)\n", + " N_cg_values[i] = N_eval\n", + "\n", + " nu = complex(nu_squared_interpolation(N_eval), 0)**0.5\n", + " # First find the full version\n", + "\n", + " delta_phi_at_sigma = analytical_delta_phi(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + " delta_phi_deriv_at_sigma =\\\n", + " analytical_delta_phi_N_derivative(N_eval, N_end, N_star, A_plus, A_minus, k)\n", + "\n", + " # Then find the R from this\n", + " R_at_sigma = R_from_delta_phi(N_eval, delta_phi_at_sigma, delta_phi_deriv_at_sigma)\n", + " R_diff_at_sigma = R_N_derivative_from_delta_phi(N_eval, delta_phi_at_sigma, delta_phi_deriv_at_sigma)\n", + "\n", + " # We use these values to find the homogeneous behaviour\n", + " A, B = R_matching_to_Bessels(R_at_sigma, R_diff_at_sigma, N_eval, N_end, nu, k)\n", + " # Now we can find delta phi from these values\n", + " delta_phi_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " delta_phi_deriv_at_sigma =\\\n", + " homogeneous_Bessel_delta_phi_N_derivative(N_eval, N_end, nu, k, A, B, just_growing=True)\n", + " tan_theta = np.real(delta_phi_deriv_at_sigma/delta_phi_at_sigma)\n", + "\n", + " epsilon1 = epsilon1_interpolation(N_eval)\n", + " covar_matrix = correlation_matrix(delta_phi_at_sigma, delta_phi_deriv_at_sigma, k, epsilon1)\n", + " covaraince_matrix = np.array([[covar_matrix[0], covar_matrix[1]], [covar_matrix[2], covar_matrix[3]]])\n", + " covar_matrix = covar_matrix.real\n", + " # The phi noise is just the element square root, then pi noise is just this times the ratio\n", + " noise_matrix_array[0, i] = covar_matrix[0]**0.5\n", + " noise_matrix_array[1, i] = tan_theta*covar_matrix[0]**0.5\n", + " data_dict = {}\n", + " data_dict[\"N\"] = N_cg_values\n", + " data_dict[\"phi-phi noise\"] = noise_matrix_array[0, :]\n", + " data_dict[\"pi-pi noise\"] = noise_matrix_array[1, :]\n", + "\n", + " data_pandas = pd.DataFrame(data_dict)\n", + "\n", + " data_pandas.to_csv(\"piece_wise_linear_noise_curves_Bessel_matched_sigma_\"+str(sigma)+\"_1D.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/User guides/Advanced/Piece_wise/Piece-wise linear potential 4 - importance sampling.ipynb b/User guides/Advanced/Piece_wise/Piece-wise linear potential 4 - importance sampling.ipynb new file mode 100644 index 0000000..194a508 --- /dev/null +++ b/User guides/Advanced/Piece_wise/Piece-wise linear potential 4 - importance sampling.ipynb @@ -0,0 +1,2261 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Piece-wise linear potential 4 - importance sampling\n", + "\n", + "This is the fourth, and final, in a series of notebooks which will run importance sampling for the piece-wise linear potential. Familiarity with importance sampling is assumed\n", + "\n", + "In this notebook we show how to run stochastic simulations and compare the different noise models.\n", + "\n", + "We start as we did before by defining everything we need and loading in the required data\n", + "\n", + "Throughout natural units with $c = 8\\pi M_{\\rm PL} = \\hbar =1$ are used." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import mystyle\n", + "plt.style.use(mystyle.paper_style)\n", + "\n", + "# Need to make sure you have pyfpt installed\n", + "import pyfpt as fpt\n", + "import multiprocessing as mp\n", + "from multiprocessing import Process, Queue\n", + "from timeit import default_timer as timer\n", + "\n", + "from scipy.optimize import root\n", + "from scipy.integrate import quad\n", + "from scipy.integrate import trapezoid\n", + "from scipy.interpolate import CubicSpline\n", + "\n", + "# Let us define the different colours used\n", + "color = ['#377eb8', '#ff7f00', '#984ea3','#4daf4a', '#a65628', '#f781bf','#999999', '#e41a1c', '#dede00']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The potential" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def potential(phi):\n", + " if phi > phi_star:\n", + " return V_0 + A_plus*(phi - phi_star)\n", + " elif phi <= phi_star:\n", + " return V_0 + A_minus*(phi - phi_star)\n", + "\n", + " \n", + "def potential_dif(phi):\n", + " if phi > phi_star:\n", + " return A_plus\n", + " elif phi <= phi_star:\n", + " return A_minus\n", + "\n", + "def potential_ddif(phi):\n", + " return 0.\n", + "\n", + "def V_prime_by_V(phi):\n", + " if phi > phi_star:\n", + " return A_plus/(V_0 + A_plus*(phi - phi_star))\n", + " elif phi <= phi_star:\n", + " return A_minus/(V_0 + A_minus*(phi - phi_star))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters are shown such that the power spectrum peaks at $5 \\times 10^{-3}$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "pi_num = np.pi\n", + "\n", + "A_plus = 10**-14\n", + "A_minus = A_plus*(10**-3)\n", + "cmb_power_spectrum = 2*10**-9\n", + "V_0 = (12*cmb_power_spectrum*(pi_num*A_plus)**2)**(1/3)\n", + "H_0 = (V_0/3)**(1/2)\n", + "N_star = 26.\n", + "phi_star = 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading in background\n", + "We have already simulated the background, now we can just load it in." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "background_data = pd.read_csv(\"piece_wise_linear_dynamics_dynamics\"+\".csv\", index_col=0)\n", + "\n", + "N_values = np.array(background_data[\"N\"])\n", + "phi_values = np.array(background_data[\"phi\"])\n", + "phi_diff_values = np.array(background_data[\"phi_N_diff\"])\n", + "hubble_param_values = np.array(background_data[\"H\"])\n", + "epsilon1_values = np.array(background_data[\"epsilon1\"])\n", + "epsilon2_values = np.array(background_data[\"epsilon2\"])\n", + "nu_squared_values = np.array(background_data[\"nu_squared\"])\n", + "\n", + "N_end = N_values[-1]\n", + "phi_end_true = phi_values[-1]\n", + "a_in = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "hubble_param_interpolation = CubicSpline(N_values, hubble_param_values)\n", + "\n", + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_star))\n", + "\n", + "phi_with_scale_interpolation = CubicSpline(aH_interpolation(N_values), phi_values)\n", + "phi_diff_with_scale_interpolation = CubicSpline(aH_interpolation(N_values), phi_diff_values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Updating the interpolation which are senstive to any errors to use the analytical versions." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def comoving_time_func(N_interest, N_end):\n", + " def comoving_time_integrand(N):\n", + " aH = aH_interpolation(N)\n", + " return 1/aH\n", + " comoving_time_value, _ = quad(comoving_time_integrand, N_end, N_interest, limit=1000)\n", + " return comoving_time_value\n", + "\n", + "def analytical_epsilon_1(N_interest, N_end, N_transition, A_plus, A_minus):\n", + " H = hubble_param_interpolation(N_interest)\n", + " if N_interest<=N_transition:\n", + " epsilon_1 = (A_plus**2)/(18*(H**4))\n", + " elif N_interest>N_transition:\n", + " Delta_A = A_minus - A_plus\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_transition = aH_interpolation(N_transition)\n", + " epsilon_1 = ((Delta_A*(comoving_time*k_transition)**3 + A_minus)**2)/(18*(H**4))\n", + " return epsilon_1\n", + "\n", + "def analytical_epsilon_2(N_interest, N_end, N_transition, A_plus, A_minus):\n", + " H = hubble_param_interpolation(N_interest)\n", + " if N_interest<=N_transition:\n", + " epsilon_2 = 0.\n", + " elif N_interest>N_transition:\n", + " Delta_A = A_minus - A_plus\n", + " comoving_time = comoving_time_func(N_interest, N_end)\n", + " k_transition = aH_interpolation(N_transition)\n", + " epsilon_2 =\\\n", + " (-6*Delta_A*(comoving_time*k_transition)**3)/(Delta_A*(comoving_time*k_transition)**3 + A_minus)\n", + " return epsilon_2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "epsilon1_values = np.array([analytical_epsilon_1(N_values[i], N_end, N_star, A_plus, A_minus) for i in range(len(N_values))])\n", + "epsilon2_values = np.array([analytical_epsilon_2(N_values[i], N_end, N_star, A_plus, A_minus) for i in range(len(N_values))])\n", + "\n", + "# interpolation\n", + "epsilon1_interpolation = CubicSpline(N_values, epsilon1_values)\n", + "epsilon2_interpolation = CubicSpline(N_values, epsilon2_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def nu_sqaured_func(N):\n", + " epsilon2 = epsilon2_interpolation(N, 0)\n", + " epsilon1 = epsilon1_interpolation(N, 0)\n", + " epsilon2_derivative = epsilon2_interpolation(N, 1)\n", + " return 9/4 - epsilon1 + (3/2)*epsilon2 - (1/2)*epsilon1*epsilon2 + (epsilon2**2)/4\\\n", + " + epsilon2_derivative/2" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "nu_squared_values = np.array([nu_sqaured_func(N_values[i]) for i in range(len(N_values))])\n", + "\n", + "nu_squared_interpolation = CubicSpline(N_values, nu_squared_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "aH_interpolation = CubicSpline(N_values, hubble_param_values*a_in*np.exp(N_values-N_star))\n", + "a_interpolation = CubicSpline(N_values, a_in*np.exp(N_values-N_star))\n", + "\n", + "N_sim_end_estimate = N_star + np.log(10**3)\n", + "\n", + "sim_range_logic = (N_values>N_star+0.05) & (N_valuesN_transition:\n", + " alpha = 1. + complex(0, 1)*(3*Delta_A*k_0/(2*A_plus*k))*(1 + (k_0/k)**2)\n", + " beta = complex(0, -1)*(3*Delta_A*k_0/(2*A_plus*k))*np.exp(complex(0, 2*k/k_0))*(complex(1, k_0/k)**2)\n", + " else:\n", + " alpha = 1.\n", + " beta = 0.\n", + "\n", + " term1 = complex(1, k_eta)*np.exp(complex(0, -k_eta))\n", + " term2 = complex(1, -k_eta)*np.exp(complex(0, k_eta))\n", + " k_term = complex(0, H0/(2*k**3)**0.5)\n", + "\n", + " delta_phi = k_term*(alpha*term1 - beta*term2)\n", + " return delta_phi" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def power_spectrum_func(k, R):\n", + " return (np.abs(R)**2)*(k**3)/(2*np.pi**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Importance sampling\n", + "\n", + "Here we run simulations using importance sampling to investigate the far tail. As it is more straightforward to implement the 1D noise, that is what we do here. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext cython" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " Cython: _cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.pyx\n", + " \n", + "\n", + "\n", + "

Generated by Cython 3.0.7

\n", + "

\n", + " Yellow lines hint at Python interaction.
\n", + " Click on a line that starts with a \"+\" to see the C code that Cython generated for it.\n", + "

\n", + "
 001:
\n", + "
+002: import numpy as np
\n", + "
  __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 2, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 003:
\n", + "
+004: cdef double e = 2.718281828459045
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_e = 2.718281828459045;\n",
+       "
+005: cdef double pi_const = 3.141592653589793
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_pi_const = 3.141592653589793;\n",
+       "
+006: cdef double phi_star = 1.0
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star = 1.0;\n",
+       "
+007: cdef double A_plus = 1e-14
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_plus = 1e-14;\n",
+       "
+008: cdef double A_minus = 1e-17
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_minus = 1e-17;\n",
+       "
+009: cdef double V_0 = 2.871906714642027e-12
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_0 = 2.871906714642027e-12;\n",
+       "
+010: cdef double diff_const = 1.5572025557368665e-07
\n", + "
  __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_diff_const = 1.5572025557368665e-07;\n",
+       "
 011: cdef double phi_old
\n", + "
 012:
\n", + "
 013:
\n", + "
+014: cdef double V_prime_by_V_cython(double phi):
\n", + "
static double __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_prime_by_V_cython(double __pyx_v_phi) {\n",
+       "  double __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_r = 0;\n",
+       "  goto __pyx_L0;\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.V_prime_by_V_cython\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = -1;\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+015:     if phi > phi_star:
\n", + "
  __pyx_t_1 = (__pyx_v_phi > __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+016:         return A_plus/(V_0 + A_plus*(phi - phi_star))
\n", + "
    __pyx_t_2 = (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_0 + (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_plus * (__pyx_v_phi - __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star)));\n",
+       "    if (unlikely(__pyx_t_2 == 0)) {\n",
+       "      PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "      __PYX_ERR(0, 16, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_r = (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_plus / __pyx_t_2);\n",
+       "    goto __pyx_L0;\n",
+       "
+017:     elif phi <= phi_star:
\n", + "
  __pyx_t_1 = (__pyx_v_phi <= __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+018:         return A_minus/(V_0 + A_minus*(phi - phi_star))
\n", + "
    __pyx_t_2 = (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_0 + (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_minus * (__pyx_v_phi - __pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_phi_star)));\n",
+       "    if (unlikely(__pyx_t_2 == 0)) {\n",
+       "      PyErr_SetString(PyExc_ZeroDivisionError, \"float division\");\n",
+       "      __PYX_ERR(0, 18, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_r = (__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_A_minus / __pyx_t_2);\n",
+       "    goto __pyx_L0;\n",
+       "
 019:
\n", + "
+020: cdef int end_cond(double phi, double pi, double N, double phi_end):
\n", + "
static int __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_end_cond(double __pyx_v_phi, CYTHON_UNUSED double __pyx_v_pi, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_phi_end) {\n",
+       "  int __pyx_r;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L0:;\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
+021:     if phi<phi_end:
\n", + "
  __pyx_t_1 = (__pyx_v_phi < __pyx_v_phi_end);\n",
+       "  if (__pyx_t_1) {\n",
+       "/* … */\n",
+       "  }\n",
+       "
+022:         return 1
\n", + "
    __pyx_r = 1;\n",
+       "    goto __pyx_L0;\n",
+       "
 023:     else:
\n", + "
+024:         return 0
\n", + "
  /*else*/ {\n",
+       "    __pyx_r = 0;\n",
+       "    goto __pyx_L0;\n",
+       "  }\n",
+       "
 025:
\n", + "
 026:
\n", + "
+027: cdef list update(double phi, double pi, double A, double N, double dN, double [:] dW, double [:] noise,
\n", + "
static PyObject *__pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_update(double __pyx_v_phi, double __pyx_v_pi, double __pyx_v_A, CYTHON_UNUSED double __pyx_v_N, double __pyx_v_dN, __Pyx_memviewslice __pyx_v_dW, __Pyx_memviewslice __pyx_v_noise, double __pyx_v_bias_amp) {\n",
+       "  double __pyx_v_phi_old;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_7);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_XDECREF(__pyx_t_9);\n",
+       "  __Pyx_XDECREF(__pyx_t_10);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.update\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 028:                  double bias_amp):
\n", + "
 029:     # Store old phi value to be used in calculating velocity
\n", + "
+030:     phi_old = phi
\n", + "
  __pyx_v_phi_old = __pyx_v_phi;\n",
+       "
 031:     # Update field position
\n", + "
 032:     # If noise is zero, no bias is automatically applied
\n", + "
+033:     phi = phi + (pi + bias_amp*noise[0])*dN + noise[0]*dW[0]
\n", + "
  __pyx_t_1 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_1 < 0) {\n",
+       "    __pyx_t_1 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_1 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_3 < 0) {\n",
+       "    __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_4 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_dW.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 33, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_v_phi = ((__pyx_v_phi + ((__pyx_v_pi + (__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_1 * __pyx_v_noise.strides[0]) ))))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_4 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 034:
\n", + "
 035:     # Update the velocity
\n", + "
+036:     if noise[0]>0:  #Need to include the chance the noise is zero
\n", + "
  __pyx_t_4 = 0;\n",
+       "  __pyx_t_2 = -1;\n",
+       "  if (__pyx_t_4 < 0) {\n",
+       "    __pyx_t_4 += __pyx_v_noise.shape[0];\n",
+       "    if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "  } else if (unlikely(__pyx_t_4 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "  if (unlikely(__pyx_t_2 != -1)) {\n",
+       "    __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "    __PYX_ERR(0, 36, __pyx_L1_error)\n",
+       "  }\n",
+       "  __pyx_t_5 = ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_4 * __pyx_v_noise.strides[0]) ))) > 0.0);\n",
+       "  if (__pyx_t_5) {\n",
+       "/* … */\n",
+       "    goto __pyx_L3;\n",
+       "  }\n",
+       "
 037:         pi =\\
\n", + "
+038:             pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN +\\
\n", + "
    __pyx_t_6 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_prime_by_V_cython(__pyx_v_phi_old); if (unlikely(__pyx_t_6 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error)\n",
+       "
+039:              bias_amp*noise[1]*dN + noise[1]*dW[0]
\n", + "
    __pyx_t_4 = 1;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_4 < 0) {\n",
+       "      __pyx_t_4 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_4 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_4 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 39, __pyx_L1_error)\n",
+       "    }\n",
+       "/* … */\n",
+       "    __pyx_t_3 = 1;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_3 < 0) {\n",
+       "      __pyx_t_3 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_3 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_3 >= __pyx_v_noise.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 39, __pyx_L1_error)\n",
+       "    }\n",
+       "/* … */\n",
+       "    __pyx_t_1 = 0;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_1 < 0) {\n",
+       "      __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 39, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_v_pi = (((__pyx_v_pi - (((3.0 - (0.5 * pow(__pyx_v_pi, 2.0))) * (__pyx_v_pi + __pyx_t_6)) * __pyx_v_dN)) + ((__pyx_v_bias_amp * (*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_4 * __pyx_v_noise.strides[0]) )))) * __pyx_v_dN)) + ((*((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_3 * __pyx_v_noise.strides[0]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) )))));\n",
+       "
 040:
\n", + "
 041:         # Use the standard form for the weight calculation
\n", + "
+042:         A += bias_amp*(0.5*bias_amp*dN + dW[0])
\n", + "
    __pyx_t_1 = 0;\n",
+       "    __pyx_t_2 = -1;\n",
+       "    if (__pyx_t_1 < 0) {\n",
+       "      __pyx_t_1 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;\n",
+       "    } else if (unlikely(__pyx_t_1 >= __pyx_v_dW.shape[0])) __pyx_t_2 = 0;\n",
+       "    if (unlikely(__pyx_t_2 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_2);\n",
+       "      __PYX_ERR(0, 42, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_v_A = (__pyx_v_A + (__pyx_v_bias_amp * (((0.5 * __pyx_v_bias_amp) * __pyx_v_dN) + (*((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_1 * __pyx_v_dW.strides[0]) ))))));\n",
+       "
 043:     else:
\n", + "
+044:         pi =\\
\n", + "
  /*else*/ {\n",
+       "
+045:             pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN
\n", + "
    __pyx_t_6 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_V_prime_by_V_cython(__pyx_v_phi_old); if (unlikely(__pyx_t_6 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 45, __pyx_L1_error)\n",
+       "    __pyx_v_pi = (__pyx_v_pi - (((3.0 - (0.5 * pow(__pyx_v_pi, 2.0))) * (__pyx_v_pi + __pyx_t_6)) * __pyx_v_dN));\n",
+       "
 046:         # No change as no noise is applied.
\n", + "
+047:         A += 0.
\n", + "
    __pyx_v_A = (__pyx_v_A + 0.);\n",
+       "  }\n",
+       "  __pyx_L3:;\n",
+       "
 048:
\n", + "
+049:     return [phi, pi, A]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_phi); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_pi); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_8);\n",
+       "  __pyx_t_9 = PyFloat_FromDouble(__pyx_v_A); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_9);\n",
+       "  __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 49, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_10);\n",
+       "  __Pyx_GIVEREF(__pyx_t_7);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_8);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_8)) __PYX_ERR(0, 49, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_9);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_t_9)) __PYX_ERR(0, 49, __pyx_L1_error);\n",
+       "  __pyx_t_7 = 0;\n",
+       "  __pyx_t_8 = 0;\n",
+       "  __pyx_t_9 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_10);\n",
+       "  __pyx_t_10 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 050:
\n", + "
 051:
\n", + "
 052: #A let's us calculate the bias w=e^-A is the bias, which propagated along with
\n", + "
 053: #the importance sample path.
\n", + "
 054: #See Eq. (33) of arXiv:nucl-th/9809075v1 for more info
\n", + "
+055: cdef list simulation_diff_general_end(double x_in, double y_in, double t_in,\\
\n", + "
static PyObject *__pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_simulation_diff_general_end(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, PyObject *__pyx_v_rng) {\n",
+       "  double __pyx_v_t;\n",
+       "  double __pyx_v_sqrt_dt;\n",
+       "  double __pyx_v_x;\n",
+       "  double __pyx_v_y;\n",
+       "  double __pyx_v_A;\n",
+       "  int __pyx_v_i;\n",
+       "  int __pyx_v_end_cond_value;\n",
+       "  int __pyx_v_len_rand_nums;\n",
+       "  int __pyx_v_reduced_step;\n",
+       "  int __pyx_v_num_steps;\n",
+       "  __Pyx_memviewslice __pyx_v_rand_nums = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_dW = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  __Pyx_memviewslice __pyx_v_noise = { 0, 0, { 0 }, { 0 }, { 0 } };\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_4);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.simulation_diff_general_end\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_dW, 1);\n",
+       "  __PYX_XCLEAR_MEMVIEW(&__pyx_v_noise, 1);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "
 056:                           double t_f, double dt, double bias_amp, double phi_end_in, noise_list, rng):
\n", + "
 057:     cdef double t, sqrt_dt, x, y, z, A
\n", + "
+058:     cdef int i = 0
\n", + "
  __pyx_v_i = 0;\n",
+       "
 059:     cdef int end_cond_value
\n", + "
+060:     cdef int len_rand_nums = 1000
\n", + "
  __pyx_v_len_rand_nums = 0x3E8;\n",
+       "
+061:     cdef int reduced_step = 0
\n", + "
  __pyx_v_reduced_step = 0;\n",
+       "
+062:     cdef int num_steps = 0
\n", + "
  __pyx_v_num_steps = 0;\n",
+       "
 063:
\n", + "
 064:     cdef double [:, :] rand_nums
\n", + "
 065:     cdef double [:] dW
\n", + "
 066:     cdef double [:] noise
\n", + "
 067:
\n", + "
+068:     t = t_in
\n", + "
  __pyx_v_t = __pyx_v_t_in;\n",
+       "
+069:     x = x_in
\n", + "
  __pyx_v_x = __pyx_v_x_in;\n",
+       "
+070:     y = y_in
\n", + "
  __pyx_v_y = __pyx_v_y_in;\n",
+       "
+071:     sqrt_dt = dt**0.5
\n", + "
  __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+072:     A = 0.0
\n", + "
  __pyx_v_A = 0.0;\n",
+       "
+073:     rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_INCREF(__pyx_int_2);\n",
+       "  __Pyx_GIVEREF(__pyx_int_2);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_2)) __PYX_ERR(0, 73, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error);\n",
+       "  __pyx_t_3 = 0;\n",
+       "  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_4) < 0) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__9, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_rand_nums = __pyx_t_5;\n",
+       "  __pyx_t_5.memview = NULL;\n",
+       "  __pyx_t_5.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__9 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 73, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__9);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__9);\n",
+       "
+074:     dW = rand_nums[:, 0]
\n", + "
  __pyx_t_6.data = __pyx_v_rand_nums.data;\n",
+       "  __pyx_t_6.memview = __pyx_v_rand_nums.memview;\n",
+       "  __PYX_INC_MEMVIEW(&__pyx_t_6, 1);\n",
+       "  __pyx_t_6.shape[0] = __pyx_v_rand_nums.shape[0];\n",
+       "__pyx_t_6.strides[0] = __pyx_v_rand_nums.strides[0];\n",
+       "    __pyx_t_6.suboffsets[0] = -1;\n",
+       "\n",
+       "{\n",
+       "    Py_ssize_t __pyx_tmp_idx = 0;\n",
+       "        Py_ssize_t __pyx_tmp_shape = __pyx_v_rand_nums.shape[1];\n",
+       "    Py_ssize_t __pyx_tmp_stride = __pyx_v_rand_nums.strides[1];\n",
+       "        if (__pyx_tmp_idx < 0)\n",
+       "            __pyx_tmp_idx += __pyx_tmp_shape;\n",
+       "        if (unlikely(!__Pyx_is_valid_index(__pyx_tmp_idx, __pyx_tmp_shape))) {\n",
+       "            PyErr_SetString(PyExc_IndexError,\n",
+       "                            \"Index out of bounds (axis 1)\");\n",
+       "            __PYX_ERR(0, 74, __pyx_L1_error)\n",
+       "        }\n",
+       "        __pyx_t_6.data += __pyx_tmp_idx * __pyx_tmp_stride;\n",
+       "}\n",
+       "\n",
+       "__pyx_v_dW = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "
+075:     noise = noise_list[:, 0]
\n", + "
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_tuple__10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 75, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_4, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 75, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "  __pyx_v_noise = __pyx_t_6;\n",
+       "  __pyx_t_6.memview = NULL;\n",
+       "  __pyx_t_6.data = NULL;\n",
+       "/* … */\n",
+       "  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_slice__5, __pyx_int_0); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 75, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__10);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__10);\n",
+       "
 076:
\n", + "
+077:     while t<t_f:
\n", + "
  while (1) {\n",
+       "    __pyx_t_7 = (__pyx_v_t < __pyx_v_t_f);\n",
+       "    if (!__pyx_t_7) break;\n",
+       "
 078:         # Scale the step varaince to the dt used
\n", + "
+079:         dW[0] = sqrt_dt*rand_nums[0, i]
\n", + "
    __pyx_t_8 = 0;\n",
+       "    __pyx_t_9 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 79, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_8 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_9 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
+080:         dW[1] = sqrt_dt*rand_nums[1, i]
\n", + "
    __pyx_t_9 = 1;\n",
+       "    __pyx_t_8 = __pyx_v_i;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_9 < 0) {\n",
+       "      __pyx_t_9 += __pyx_v_rand_nums.shape[0];\n",
+       "      if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_9 >= __pyx_v_rand_nums.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_rand_nums.shape[1];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 1;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_rand_nums.shape[1])) __pyx_t_10 = 1;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "    }\n",
+       "    __pyx_t_11 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_11 < 0) {\n",
+       "      __pyx_t_11 += __pyx_v_dW.shape[0];\n",
+       "      if (unlikely(__pyx_t_11 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_11 >= __pyx_v_dW.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 80, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_dW.data + __pyx_t_11 * __pyx_v_dW.strides[0]) )) = (__pyx_v_sqrt_dt * (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rand_nums.data + __pyx_t_9 * __pyx_v_rand_nums.strides[0]) ) + __pyx_t_8 * __pyx_v_rand_nums.strides[1]) ))));\n",
+       "
 081:         # Find the noise from the list provided
\n", + "
+082:         noise[0] = noise_list[0, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_0);\n",
+       "    __Pyx_GIVEREF(__pyx_int_0);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_0)) __PYX_ERR(0, 82, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 0;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 82, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
+083:         noise[1] = noise_list[1, num_steps]
\n", + "
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_num_steps); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_int_1);\n",
+       "    __Pyx_GIVEREF(__pyx_int_1);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_1)) __PYX_ERR(0, 83, __pyx_L1_error);\n",
+       "    __Pyx_GIVEREF(__pyx_t_4);\n",
+       "    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error);\n",
+       "    __pyx_t_4 = 0;\n",
+       "    __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_noise_list, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    __pyx_t_8 = 1;\n",
+       "    __pyx_t_10 = -1;\n",
+       "    if (__pyx_t_8 < 0) {\n",
+       "      __pyx_t_8 += __pyx_v_noise.shape[0];\n",
+       "      if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0;\n",
+       "    } else if (unlikely(__pyx_t_8 >= __pyx_v_noise.shape[0])) __pyx_t_10 = 0;\n",
+       "    if (unlikely(__pyx_t_10 != -1)) {\n",
+       "      __Pyx_RaiseBufferIndexError(__pyx_t_10);\n",
+       "      __PYX_ERR(0, 83, __pyx_L1_error)\n",
+       "    }\n",
+       "    *((double *) ( /* dim=0 */ (__pyx_v_noise.data + __pyx_t_8 * __pyx_v_noise.strides[0]) )) = __pyx_t_12;\n",
+       "
 084:         # Define the Wiener step, using the pre-drawn random numbers.
\n", + "
 085:         # Step in x and A simultanioues
\n", + "
+086:         [x, y, A] =\\
\n", + "
    __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_12 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    __pyx_t_13 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "    __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    __pyx_v_x = __pyx_t_12;\n",
+       "    __pyx_v_y = __pyx_t_13;\n",
+       "    __pyx_v_A = __pyx_t_14;\n",
+       "
+087:             update(x, y, A, t, dt, dW, noise, bias_amp)
\n", + "
    __pyx_t_4 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_update(__pyx_v_x, __pyx_v_y, __pyx_v_A, __pyx_v_t, __pyx_v_dt, __pyx_v_dW, __pyx_v_noise, __pyx_v_bias_amp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_4);\n",
+       "    if (likely(__pyx_t_4 != Py_None)) {\n",
+       "      PyObject* sequence = __pyx_t_4;\n",
+       "      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "      if (unlikely(size != 3)) {\n",
+       "        if (size > 3) __Pyx_RaiseTooManyValuesError(3);\n",
+       "        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "        __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "      }\n",
+       "      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); \n",
+       "      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); \n",
+       "      __Pyx_INCREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_1);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      #else\n",
+       "      __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      #endif\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "    } else {\n",
+       "      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 86, __pyx_L1_error)\n",
+       "    }\n",
+       "
+088:         t += dt
\n", + "
    __pyx_v_t = (__pyx_v_t + __pyx_v_dt);\n",
+       "
+089:         i += 1
\n", + "
    __pyx_v_i = (__pyx_v_i + 1);\n",
+       "
+090:         num_steps += 1
\n", + "
    __pyx_v_num_steps = (__pyx_v_num_steps + 1);\n",
+       "
 091:         # Using 1/0 for True/False
\n", + "
+092:         end_cond_value = end_cond(x, y, t, phi_end_in)
\n", + "
    __pyx_t_10 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_end_cond(__pyx_v_x, __pyx_v_y, __pyx_v_t, __pyx_v_phi_end_in); if (unlikely(__pyx_t_10 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error)\n",
+       "    __pyx_v_end_cond_value = __pyx_t_10;\n",
+       "
+093:         if end_cond_value == 1:
\n", + "
    __pyx_t_7 = (__pyx_v_end_cond_value == 1);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "
+094:             break
\n", + "
      goto __pyx_L4_break;\n",
+       "
+095:         elif end_cond_value == -1 and reduced_step == 0:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == -1L);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L6_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 0);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L6_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "      goto __pyx_L5;\n",
+       "    }\n",
+       "
+096:             dt = dt/100
\n", + "
      __pyx_v_dt = (__pyx_v_dt / 100.0);\n",
+       "
+097:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+098:             reduced_step = 1
\n", + "
      __pyx_v_reduced_step = 1;\n",
+       "
+099:         elif end_cond_value == 0 and reduced_step == 1:
\n", + "
    __pyx_t_15 = (__pyx_v_end_cond_value == 0);\n",
+       "    if (__pyx_t_15) {\n",
+       "    } else {\n",
+       "      __pyx_t_7 = __pyx_t_15;\n",
+       "      goto __pyx_L8_bool_binop_done;\n",
+       "    }\n",
+       "    __pyx_t_15 = (__pyx_v_reduced_step == 1);\n",
+       "    __pyx_t_7 = __pyx_t_15;\n",
+       "    __pyx_L8_bool_binop_done:;\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "    __pyx_L5:;\n",
+       "
+100:             dt = 100*dt
\n", + "
      __pyx_v_dt = (100.0 * __pyx_v_dt);\n",
+       "
+101:             sqrt_dt = dt**0.5
\n", + "
      __pyx_v_sqrt_dt = pow(__pyx_v_dt, 0.5);\n",
+       "
+102:             reduced_step = 0
\n", + "
      __pyx_v_reduced_step = 0;\n",
+       "
 103:         # If all of the random numbers have been used up, need to update them.
\n", + "
 104:         # This should still be more efficient than drawing a new random number
\n", + "
 105:         # each time.
\n", + "
+106:         if i == len_rand_nums:
\n", + "
    __pyx_t_7 = (__pyx_v_i == __pyx_v_len_rand_nums);\n",
+       "    if (__pyx_t_7) {\n",
+       "/* … */\n",
+       "    }\n",
+       "  }\n",
+       "  __pyx_L4_break:;\n",
+       "
+107:             rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))
\n", + "
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rng, __pyx_n_s_normal); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_4);\n",
+       "      __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_3);\n",
+       "      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_len_rand_nums); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_1);\n",
+       "      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_int_2);\n",
+       "      __Pyx_GIVEREF(__pyx_int_2);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_2)) __PYX_ERR(0, 107, __pyx_L1_error);\n",
+       "      __Pyx_GIVEREF(__pyx_t_1);\n",
+       "      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error);\n",
+       "      __pyx_t_1 = 0;\n",
+       "      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_size, __pyx_t_2) < 0) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__9, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n",
+       "      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "      __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 107, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "      __PYX_XCLEAR_MEMVIEW(&__pyx_v_rand_nums, 1);\n",
+       "      __pyx_v_rand_nums = __pyx_t_5;\n",
+       "      __pyx_t_5.memview = NULL;\n",
+       "      __pyx_t_5.data = NULL;\n",
+       "
+108:             i = 0
\n", + "
      __pyx_v_i = 0;\n",
+       "
+109:     return [t, e**(-A)]
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_16 = __Pyx_c_pow_double(__pyx_t_double_complex_from_parts(__pyx_v_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_e, 0), __pyx_t_double_complex_from_parts((-__pyx_v_A), 0));\n",
+       "  __pyx_t_3 = __pyx_Py_FromSoftComplex(__pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 109, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 109, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_4);\n",
+       "  __Pyx_GIVEREF(__pyx_t_2);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error);\n",
+       "  __Pyx_GIVEREF(__pyx_t_3);\n",
+       "  if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 109, __pyx_L1_error);\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_t_3 = 0;\n",
+       "  __pyx_r = ((PyObject*)__pyx_t_4);\n",
+       "  __pyx_t_4 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
 110:
\n", + "
 111:
\n", + "
+112: cpdef importance_sampling_simulations_2dim_1d_noise(double x_in, double y_in, double t_in, double t_f,
\n", + "
static PyObject *__pyx_pw_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyObject *__pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_importance_sampling_simulations_2dim_1d_noise(double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list, CYTHON_UNUSED int __pyx_skip_dispatch) {\n",
+       "  PyObject *__pyx_v_rng = NULL;\n",
+       "  PyObject *__pyx_v_results = NULL;\n",
+       "  PyObject *__pyx_v_ts = NULL;\n",
+       "  PyObject *__pyx_v_ws = NULL;\n",
+       "  CYTHON_UNUSED int __pyx_7genexpr__pyx_v_i;\n",
+       "  long __pyx_8genexpr1__pyx_v_j;\n",
+       "  int __pyx_8genexpr2__pyx_v_i;\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "/* … */\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_XDECREF(__pyx_t_2);\n",
+       "  __Pyx_XDECREF(__pyx_t_3);\n",
+       "  __Pyx_XDECREF(__pyx_t_8);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.importance_sampling_simulations_2dim_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = 0;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XDECREF(__pyx_v_rng);\n",
+       "  __Pyx_XDECREF(__pyx_v_results);\n",
+       "  __Pyx_XDECREF(__pyx_v_ts);\n",
+       "  __Pyx_XDECREF(__pyx_v_ws);\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "/* Python wrapper */\n",
+       "static PyObject *__pyx_pw_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       "); /*proto*/\n",
+       "static PyMethodDef __pyx_mdef_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise = {\"importance_sampling_simulations_2dim_1d_noise\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
+       "static PyObject *__pyx_pw_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise(PyObject *__pyx_self, \n",
+       "#if CYTHON_METH_FASTCALL\n",
+       "PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
+       "#else\n",
+       "PyObject *__pyx_args, PyObject *__pyx_kwds\n",
+       "#endif\n",
+       ") {\n",
+       "  double __pyx_v_x_in;\n",
+       "  double __pyx_v_y_in;\n",
+       "  double __pyx_v_t_in;\n",
+       "  double __pyx_v_t_f;\n",
+       "  double __pyx_v_dt;\n",
+       "  int __pyx_v_num_runs;\n",
+       "  double __pyx_v_bias_amp;\n",
+       "  double __pyx_v_phi_end_in;\n",
+       "  PyObject *__pyx_v_noise_list = 0;\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  CYTHON_UNUSED Py_ssize_t __pyx_nargs;\n",
+       "  #endif\n",
+       "  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;\n",
+       "  PyObject *__pyx_r = 0;\n",
+       "  __Pyx_RefNannyDeclarations\n",
+       "  __Pyx_RefNannySetupContext(\"importance_sampling_simulations_2dim_1d_noise (wrapper)\", 0);\n",
+       "  #if !CYTHON_METH_FASTCALL\n",
+       "  #if CYTHON_ASSUME_SAFE_MACROS\n",
+       "  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);\n",
+       "  #else\n",
+       "  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;\n",
+       "  #endif\n",
+       "  #endif\n",
+       "  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);\n",
+       "  {\n",
+       "    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_in,&__pyx_n_s_y_in,&__pyx_n_s_t_in,&__pyx_n_s_t_f,&__pyx_n_s_dt,&__pyx_n_s_num_runs,&__pyx_n_s_bias_amp,&__pyx_n_s_phi_end_in,&__pyx_n_s_noise_list,0};\n",
+       "  PyObject* values[9] = {0,0,0,0,0,0,0,0,0};\n",
+       "    if (__pyx_kwds) {\n",
+       "      Py_ssize_t kw_args;\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  0: break;\n",
+       "        default: goto __pyx_L5_argtuple_error;\n",
+       "      }\n",
+       "      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);\n",
+       "      switch (__pyx_nargs) {\n",
+       "        case  0:\n",
+       "        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_x_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else goto __pyx_L5_argtuple_error;\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  1:\n",
+       "        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_y_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 1); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  2:\n",
+       "        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 2); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  3:\n",
+       "        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_f)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 3); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  4:\n",
+       "        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dt)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 4); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  5:\n",
+       "        if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_num_runs)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[5]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 5); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  6:\n",
+       "        if (likely((values[6] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bias_amp)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[6]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 6); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  7:\n",
+       "        if (likely((values[7] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_phi_end_in)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[7]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 7); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "        CYTHON_FALLTHROUGH;\n",
+       "        case  8:\n",
+       "        if (likely((values[8] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_noise_list)) != 0)) {\n",
+       "          (void)__Pyx_Arg_NewRef_FASTCALL(values[8]);\n",
+       "          kw_args--;\n",
+       "        }\n",
+       "        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        else {\n",
+       "          __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, 8); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "        }\n",
+       "      }\n",
+       "      if (unlikely(kw_args > 0)) {\n",
+       "        const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
+       "        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"importance_sampling_simulations_2dim_1d_noise\") < 0)) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "      }\n",
+       "    } else if (unlikely(__pyx_nargs != 9)) {\n",
+       "      goto __pyx_L5_argtuple_error;\n",
+       "    } else {\n",
+       "      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);\n",
+       "      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);\n",
+       "      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);\n",
+       "      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);\n",
+       "      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);\n",
+       "      values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5);\n",
+       "      values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6);\n",
+       "      values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7);\n",
+       "      values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8);\n",
+       "    }\n",
+       "    __pyx_v_x_in = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_x_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "    __pyx_v_y_in = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_y_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "    __pyx_v_t_in = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_t_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "    __pyx_v_t_f = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_t_f == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "    __pyx_v_dt = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_dt == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)\n",
+       "    __pyx_v_num_runs = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_num_runs == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)\n",
+       "    __pyx_v_bias_amp = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_bias_amp == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)\n",
+       "    __pyx_v_phi_end_in = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_phi_end_in == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)\n",
+       "    __pyx_v_noise_list = values[8];\n",
+       "  }\n",
+       "  goto __pyx_L6_skip;\n",
+       "  __pyx_L5_argtuple_error:;\n",
+       "  __Pyx_RaiseArgtupleInvalid(\"importance_sampling_simulations_2dim_1d_noise\", 1, 9, 9, __pyx_nargs); __PYX_ERR(0, 112, __pyx_L3_error)\n",
+       "  __pyx_L6_skip:;\n",
+       "  goto __pyx_L4_argument_unpacking_done;\n",
+       "  __pyx_L3_error:;\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.importance_sampling_simulations_2dim_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return NULL;\n",
+       "  __pyx_L4_argument_unpacking_done:;\n",
+       "  __pyx_r = __pyx_pf_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_importance_sampling_simulations_2dim_1d_noise(__pyx_self, __pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list);\n",
+       "  int __pyx_lineno = 0;\n",
+       "  const char *__pyx_filename = NULL;\n",
+       "  int __pyx_clineno = 0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  {\n",
+       "    Py_ssize_t __pyx_temp;\n",
+       "    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {\n",
+       "      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);\n",
+       "    }\n",
+       "  }\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "\n",
+       "static PyObject *__pyx_pf_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_importance_sampling_simulations_2dim_1d_noise(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x_in, double __pyx_v_y_in, double __pyx_v_t_in, double __pyx_v_t_f, double __pyx_v_dt, int __pyx_v_num_runs, double __pyx_v_bias_amp, double __pyx_v_phi_end_in, PyObject *__pyx_v_noise_list) {\n",
+       "  PyObject *__pyx_r = NULL;\n",
+       "  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_importance_sampling_simulations_2dim_1d_noise(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_num_runs, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "\n",
+       "  /* function exit code */\n",
+       "  __pyx_L1_error:;\n",
+       "  __Pyx_XDECREF(__pyx_t_1);\n",
+       "  __Pyx_AddTraceback(\"_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999.importance_sampling_simulations_2dim_1d_noise\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
+       "  __pyx_r = NULL;\n",
+       "  __pyx_L0:;\n",
+       "  __Pyx_XGIVEREF(__pyx_r);\n",
+       "  __Pyx_RefNannyFinishContext();\n",
+       "  return __pyx_r;\n",
+       "}\n",
+       "/* … */\n",
+       "  __pyx_tuple__22 = PyTuple_Pack(9, __pyx_n_s_x_in, __pyx_n_s_y_in, __pyx_n_s_t_in, __pyx_n_s_t_f, __pyx_n_s_dt, __pyx_n_s_num_runs, __pyx_n_s_bias_amp, __pyx_n_s_phi_end_in, __pyx_n_s_noise_list); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 112, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_tuple__22);\n",
+       "  __Pyx_GIVEREF(__pyx_tuple__22);\n",
+       "/* … */\n",
+       "  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_1importance_sampling_simulations_2dim_1d_noise, 0, __pyx_n_s_importance_sampling_simulations, NULL, __pyx_n_s_cython_magic_21d3025fd53758f49a, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_7);\n",
+       "  if (PyDict_SetItem(__pyx_d, __pyx_n_s_importance_sampling_simulations, __pyx_t_7) < 0) __PYX_ERR(0, 112, __pyx_L1_error)\n",
+       "  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;\n",
+       "
 113:                                            double dt, int num_runs, double bias_amp, double phi_end_in,
\n", + "
 114:                                                 noise_list):
\n", + "
 115:     # As this variable is global, I can just redfine it hear
\n", + "
+116:     rng = np.random.default_rng()
\n", + "
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_3);\n",
+       "  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_default_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_2);\n",
+       "  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "  __pyx_t_3 = NULL;\n",
+       "  __pyx_t_4 = 0;\n",
+       "  #if CYTHON_UNPACK_METHODS\n",
+       "  if (likely(PyMethod_Check(__pyx_t_2))) {\n",
+       "    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);\n",
+       "    if (likely(__pyx_t_3)) {\n",
+       "      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);\n",
+       "      __Pyx_INCREF(__pyx_t_3);\n",
+       "      __Pyx_INCREF(function);\n",
+       "      __Pyx_DECREF_SET(__pyx_t_2, function);\n",
+       "      __pyx_t_4 = 1;\n",
+       "    }\n",
+       "  }\n",
+       "  #endif\n",
+       "  {\n",
+       "    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};\n",
+       "    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);\n",
+       "    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "  }\n",
+       "  __pyx_v_rng = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "
 117:     results =\\
\n", + "
+118:         [simulation_diff_general_end(x_in, y_in, t_in, t_f, dt, bias_amp, phi_end_in, noise_list, rng)\\
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "/* … */\n",
+       "      __pyx_t_2 = __pyx_f_54_cython_magic_21d3025fd53758f49a89c30f5f3975877d0de999_simulation_diff_general_end(__pyx_v_x_in, __pyx_v_y_in, __pyx_v_t_in, __pyx_v_t_f, __pyx_v_dt, __pyx_v_bias_amp, __pyx_v_phi_end_in, __pyx_v_noise_list, __pyx_v_rng); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error)\n",
+       "      __Pyx_GOTREF(__pyx_t_2);\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 118, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  __pyx_v_results = ((PyObject*)__pyx_t_1);\n",
+       "  __pyx_t_1 = 0;\n",
+       "
+119:          for i in range(num_runs)]
\n", + "
    __pyx_t_4 = __pyx_v_num_runs;\n",
+       "    __pyx_t_5 = __pyx_t_4;\n",
+       "    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "      __pyx_7genexpr__pyx_v_i = __pyx_t_6;\n",
+       "
 120:
\n", + "
 121:
\n", + "
+122:     ts, ws = [[results[i][j] for i in range(num_runs)] for j in range(2)]
\n", + "
  { /* enter inner scope */\n",
+       "    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_1);\n",
+       "    for (__pyx_t_7 = 0; __pyx_t_7 < 2; __pyx_t_7+=1) {\n",
+       "      __pyx_8genexpr1__pyx_v_j = __pyx_t_7;\n",
+       "      { /* enter inner scope */\n",
+       "        __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "        __Pyx_GOTREF(__pyx_t_2);\n",
+       "        __pyx_t_4 = __pyx_v_num_runs;\n",
+       "        __pyx_t_5 = __pyx_t_4;\n",
+       "        for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {\n",
+       "          __pyx_8genexpr2__pyx_v_i = __pyx_t_6;\n",
+       "          __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_results, __pyx_8genexpr2__pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_3);\n",
+       "          __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, __pyx_8genexpr1__pyx_v_j, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "          __Pyx_GOTREF(__pyx_t_8);\n",
+       "          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n",
+       "          if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;\n",
+       "        }\n",
+       "      } /* exit inner scope */\n",
+       "      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n",
+       "    }\n",
+       "  } /* exit inner scope */\n",
+       "  if (1) {\n",
+       "    PyObject* sequence = __pyx_t_1;\n",
+       "    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);\n",
+       "    if (unlikely(size != 2)) {\n",
+       "      if (size > 2) __Pyx_RaiseTooManyValuesError(2);\n",
+       "      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n",
+       "      __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "    }\n",
+       "    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS\n",
+       "    __pyx_t_2 = PyList_GET_ITEM(sequence, 0); \n",
+       "    __pyx_t_8 = PyList_GET_ITEM(sequence, 1); \n",
+       "    __Pyx_INCREF(__pyx_t_2);\n",
+       "    __Pyx_INCREF(__pyx_t_8);\n",
+       "    #else\n",
+       "    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_2);\n",
+       "    __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 122, __pyx_L1_error)\n",
+       "    __Pyx_GOTREF(__pyx_t_8);\n",
+       "    #endif\n",
+       "    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n",
+       "  }\n",
+       "  __pyx_v_ts = __pyx_t_2;\n",
+       "  __pyx_t_2 = 0;\n",
+       "  __pyx_v_ws = __pyx_t_8;\n",
+       "  __pyx_t_8 = 0;\n",
+       "
+123:     return ts, ws
\n", + "
  __Pyx_XDECREF(__pyx_r);\n",
+       "  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)\n",
+       "  __Pyx_GOTREF(__pyx_t_1);\n",
+       "  __Pyx_INCREF(__pyx_v_ts);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ts);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_ts)) __PYX_ERR(0, 123, __pyx_L1_error);\n",
+       "  __Pyx_INCREF(__pyx_v_ws);\n",
+       "  __Pyx_GIVEREF(__pyx_v_ws);\n",
+       "  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ws)) __PYX_ERR(0, 123, __pyx_L1_error);\n",
+       "  __pyx_r = __pyx_t_1;\n",
+       "  __pyx_t_1 = 0;\n",
+       "  goto __pyx_L0;\n",
+       "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%cython -a\n", + "\n", + "import numpy as np\n", + "\n", + "cdef double e = 2.718281828459045\n", + "cdef double pi_const = 3.141592653589793\n", + "cdef double phi_star = 1.0\n", + "cdef double A_plus = 1e-14\n", + "cdef double A_minus = 1e-17\n", + "cdef double V_0 = 2.871906714642027e-12\n", + "cdef double diff_const = 1.5572025557368665e-07\n", + "cdef double phi_old\n", + "\n", + "\n", + "cdef double V_prime_by_V_cython(double phi):\n", + " if phi > phi_star:\n", + " return A_plus/(V_0 + A_plus*(phi - phi_star))\n", + " elif phi <= phi_star:\n", + " return A_minus/(V_0 + A_minus*(phi - phi_star))\n", + " \n", + "cdef int end_cond(double phi, double pi, double N, double phi_end):\n", + " if phi0: #Need to include the chance the noise is zero\n", + " pi =\\\n", + " pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN +\\\n", + " bias_amp*noise[1]*dN + noise[1]*dW[0]\n", + "\n", + " # Use the standard form for the weight calculation\n", + " A += bias_amp*(0.5*bias_amp*dN + dW[0])\n", + " else:\n", + " pi =\\\n", + " pi - (3 - 0.5*pi**2)*(pi + V_prime_by_V_cython(phi_old))*dN\n", + " # No change as no noise is applied.\n", + " A += 0.\n", + "\n", + " return [phi, pi, A]\n", + "\n", + "\n", + "#A let's us calculate the bias w=e^-A is the bias, which propagated along with \n", + "#the importance sample path.\n", + "#See Eq. (33) of arXiv:nucl-th/9809075v1 for more info\n", + "cdef list simulation_diff_general_end(double x_in, double y_in, double t_in,\\\n", + " double t_f, double dt, double bias_amp, double phi_end_in, noise_list, rng):\n", + " cdef double t, sqrt_dt, x, y, z, A\n", + " cdef int i = 0\n", + " cdef int end_cond_value\n", + " cdef int len_rand_nums = 1000\n", + " cdef int reduced_step = 0\n", + " cdef int num_steps = 0\n", + " \n", + " cdef double [:, :] rand_nums\n", + " cdef double [:] dW\n", + " cdef double [:] noise\n", + "\n", + " t = t_in\n", + " x = x_in\n", + " y = y_in\n", + " sqrt_dt = dt**0.5\n", + " A = 0.0\n", + " rand_nums = rng.normal(0, 1, size=(2, len_rand_nums))\n", + " dW = rand_nums[:, 0]\n", + " noise = noise_list[:, 0]\n", + "\n", + " while t" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sigma = 1.\n", + "bias_amp_values = [0., 1., 2., 3.]\n", + "\n", + "for i in range(len(bias_amp_values)):\n", + " # Very important to keep everything as Python objects\n", + " bias_amp = float(bias_amp_values[i])\n", + " base_file_name = \"IS_data_x_in_1.0_iterations_100000_bias_\"+str(bias_amp)+\\\n", + " \"_sigma_\"+str(1.0)+\"_A_log_ration_-3.0scale_exited26.05102_1D_bessel.csv\"\n", + " raw_data = pd.read_csv(base_file_name, index_col=0)\n", + "\n", + " # Easier to work with NumPy arrays\n", + " Ns = np.array(raw_data['FPTs'])\n", + " ws = np.array(raw_data['ws'])\n", + "\n", + " if bias_amp==0.:\n", + " bin_centres, heights, errors = fpt.numerics.re_processing(Ns, estimator=\"naive\",\n", + " min_bin_size=100, t_f=75)\n", + " else:\n", + " bin_centres, heights, errors = fpt.numerics.re_processing(Ns, weights=ws, estimator=\"lognormal\",\n", + " min_bin_size=100, t_f=75, display=False)\n", + "\n", + " bin_centres = np.array(bin_centres) - find_cg_time(k_end_scale_later, sigma, N_sim_end_later)\n", + "\n", + " if i == 0:\n", + " bin_centres_combined = bin_centres\n", + " bin_centres_combined = np.array(bin_centres_combined)\n", + " heights_combined = heights\n", + " heights_combined = np.array(heights_combined)\n", + " errors_combined = errors\n", + " errors_combined = np.array(errors_combined)\n", + " else:\n", + " bin_centres_combined = np.concatenate((bin_centres_combined, bin_centres))\n", + " heights_combined = np.concatenate((heights_combined, heights))\n", + " errors_combined = np.concatenate((errors_combined, errors), axis=1)\n", + "\n", + " plt.errorbar(bin_centres, heights, yerr=errors, fmt=\".\", ms=7, label=\"$\\mathcal{A}=$\"+str(bias_amp),\n", + " color=color[i])\n", + "\n", + "sort_logic = np.argsort(bin_centres_combined)\n", + "bin_centres_combined = bin_centres_combined[sort_logic]\n", + "plt.plot(bin_centres_combined, classical_pdf(bin_centres_combined), color=\"k\", label=\"Gaussian\")\n", + "# Need to use log scale to see data in the far tail\n", + "plt.yscale('log')\n", + "plt.legend(fontsize=18)\n", + "plt.xlabel(r'$\\delta \\mathcal{N}$')\n", + "plt.ylabel(r'$P(\\delta \\mathcal{N})$')\n", + "plt.ylim(bottom = 0.1*np.min(heights_combined), top = 1.6*np.max(heights_combined))\n", + "plt.title(r\"Piece-wise - importance sampling\")\n", + "plt.xlim(left = np.min(bin_centres_combined)-0.05, right=np.max(bin_centres_combined)+0.05)\n", + "plt.show()\n", + "plt.clf()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clearly the data is both self-consistent and in agreement with Gaussian prediction!\n", + "\n", + "Note the lognormal estimator has detected some possible problems, but they are relatively large $p$-values. Only if $p < 10^{-5}$ should you really be concerned." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/User guides/Advanced/Piece_wise/README.md b/User guides/Advanced/Piece_wise/README.md new file mode 100644 index 0000000..3d380e4 --- /dev/null +++ b/User guides/Advanced/Piece_wise/README.md @@ -0,0 +1 @@ +In this folder we apply importance sampling to the [piece-wise linear model](https://arxiv.org/pdf/2311.03281.pdf). diff --git a/User guides/Advanced/Piece_wise/mystyle.py b/User guides/Advanced/Piece_wise/mystyle.py new file mode 100644 index 0000000..305571d --- /dev/null +++ b/User guides/Advanced/Piece_wise/mystyle.py @@ -0,0 +1,66 @@ +# flake8: noqa + +from cycler import cycler +# box style +paper_style = { + # Colour cycle + 'axes.prop_cycle': cycler(color=['#377eb8', '#ff7f00', '#984ea3', + '#4daf4a', '#a65628', '#f781bf', + '#999999', '#e41a1c', '#dede00']), + + # Line styles + 'lines.linewidth': 1.3, + 'lines.antialiased': True, + + # Error bars + 'errorbar.capsize': 3, # length of end cap on error bars in pixels + + # Font + 'font.size': 18.0, + + # Axes + 'axes.linewidth': 1.5, + 'axes.titlesize': 'x-large', + 'axes.labelsize': 'large', + 'axes.spines.top': True, + 'axes.spines.right': True, + + # Ticks + 'xtick.major.size': 6, + 'xtick.minor.size': 4, + 'xtick.major.width': 1.5, + 'xtick.minor.width': 1.5, + 'xtick.major.pad': 6, + 'xtick.minor.pad': 6, + 'xtick.labelsize': 'medium', + 'xtick.direction': 'in', + 'xtick.top': False, + + 'ytick.major.size': 6, + 'ytick.minor.size': 4, + 'ytick.major.width': 1.5, + 'ytick.minor.width': 1.5, + 'ytick.major.pad': 6, + 'ytick.minor.pad': 6, + 'ytick.labelsize': 'medium', + 'ytick.direction': 'in', + 'ytick.right': False, + + # Legend + 'legend.fancybox': True, + 'legend.fontsize': 'large', + 'legend.scatterpoints': 5, + 'legend.loc': 'best', + + # Figure + 'figure.figsize': [8, 5.2], + 'figure.titlesize': 'large', + + # Images + 'image.cmap': 'magma', + 'image.origin': 'lower', + + # Saving + 'savefig.bbox': 'tight', + 'savefig.format': 'png', +} diff --git a/User guides/Advanced/README.md b/User guides/Advanced/README.md new file mode 100644 index 0000000..2df604a --- /dev/null +++ b/User guides/Advanced/README.md @@ -0,0 +1,3 @@ +This folder contains advanced guides to implementing a modified version of PyFPT that can run 2D simulations of stochastic inflation. Two different models are detailed, along with how the noise is found. + +Each notebook relies on files generated from the previous one.