From aec4c19ed5c482a60debe551963b31aaa8435311 Mon Sep 17 00:00:00 2001 From: Grace Perkins Date: Tue, 14 Jul 2026 15:21:34 -0400 Subject: [PATCH 1/7] Initial commit --- .vscode/settings.json | 4 + graphing 6.26.ipynb | 72 +++++++ linx/chemical potential testing.ipynb | 68 ++++++ linx/const.py | 14 +- ...linx chemical potential testing 4-30.ipynb | 201 ++++++++++++++++++ linx/thermo.py | 116 ++++++++-- 6 files changed, 451 insertions(+), 24 deletions(-) create mode 100644 .vscode/settings.json create mode 100644 graphing 6.26.ipynb create mode 100644 linx/chemical potential testing.ipynb create mode 100644 linx/linx chemical potential testing 4-30.ipynb diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..4b5a294 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,4 @@ +{ + "python-envs.defaultEnvManager": "ms-python.python:conda", + "python-envs.defaultPackageManager": "ms-python.python:conda" +} \ No newline at end of file diff --git a/graphing 6.26.ipynb b/graphing 6.26.ipynb new file mode 100644 index 0000000..01b865d --- /dev/null +++ b/graphing 6.26.ipynb @@ -0,0 +1,72 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "id": "caf8ee34-cf90-4187-a792-b256ca68bcbc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + }, + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'jax'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 6\u001b[39m\n\u001b[32m 3\u001b[39m get_ipython().run_line_magic(\u001b[33m'\u001b[39m\u001b[33mautoreload\u001b[39m\u001b[33m'\u001b[39m, \u001b[33m'\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m 4\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mlinx\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mconst\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mconst\u001b[39;00m \n\u001b[32m 7\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mlinx\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mnuclear\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m NuclearRates\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mlinx\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mbackground\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m BackgroundModel\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\LINX-original\\linx\\const.py:1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjax\u001b[39;00m\n\u001b[32m 2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjax\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjnp\u001b[39;00m\n\u001b[32m 3\u001b[39m jax.config.update(\u001b[33m\"\u001b[39m\u001b[33mjax_enable_x64\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;66;03m# need this to enable float64\u001b[39;00m\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'jax'" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "%load_ext autoreload\n", + "%autoreload\n", + "import numpy as np\n", + "\n", + "import linx.const as const \n", + "from linx.nuclear import NuclearRates\n", + "from linx.background import BackgroundModel\n", + "from linx.abundances import AbundanceModel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b3deb468-af18-4607-85cf-cb2e5c9f43d8", + "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.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/linx/chemical potential testing.ipynb b/linx/chemical potential testing.ipynb new file mode 100644 index 0000000..2024abe --- /dev/null +++ b/linx/chemical potential testing.ipynb @@ -0,0 +1,68 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7e4c18c0-46cd-4c44-8238-de9d3cdf3ea4", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'equinox'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 11\u001b[39m\n\u001b[32m 7\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m sys\n\u001b[32m 8\u001b[39m \n\u001b[32m 9\u001b[39m sys.path.append(\u001b[33m\"../\"\u001b[39m)\n\u001b[32m 10\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m linx.const \u001b[38;5;28;01mas\u001b[39;00m const\n\u001b[32m---> \u001b[39m\u001b[32m11\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m linx.nuclear \u001b[38;5;28;01mimport\u001b[39;00m NuclearRates\n\u001b[32m 12\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m linx.background \u001b[38;5;28;01mimport\u001b[39;00m BackgroundModel\n\u001b[32m 13\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m linx.abundances \u001b[38;5;28;01mimport\u001b[39;00m AbundanceModel\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\LINX-original\\linx\\..\\linx\\nuclear.py:2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjax\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjnp\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mequinox\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01meqx\u001b[39;00m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01minterpax\u001b[39;00m\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mlinx\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mconst\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mconst\u001b[39;00m\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'equinox'" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload\n", + "import numpy as np\n", + "import jax.numpy as jnp\n", + "import jax\n", + "from jax import jit, vmap\n", + "import sys\n", + "\n", + "sys.path.append(\"../\")\n", + "import linx.const as const \n", + "from linx.nuclear import NuclearRates\n", + "from linx.background import BackgroundModel\n", + "from linx.abundances import AbundanceModel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ab02430-4b31-411f-b10f-6dbf596b11ed", + "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.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/linx/const.py b/linx/const.py index 28d0f1c..a4aa076 100644 --- a/linx/const.py +++ b/linx/const.py @@ -1,6 +1,11 @@ -import jax -import jax.numpy as jnp -jax.config.update("jax_enable_x64", True) # need this to enable float64 +try: + import jax + import jax.numpy as jnp + jax.config.update("jax_enable_x64", True) # need this to enable float64 +except ImportError: + import numpy as np + jnp = np + jax = None from linx.special_funcs import zeta_3 @@ -72,7 +77,8 @@ sW2 = 0.5*(1.-jnp.sqrt(1.-2.*jnp.sqrt(2.)*jnp.pi*aFS/(GF*mZ**2))) # Electron and muon coupling to Z -geL, geR, gmuL, gmuR = 1./2.+sW2, sW2, -1./2.+sW2, sW2 +geL, geR, gmuL, gmuR = 0.727, 0.233, -0.273, 0.233 #from NuDec_Const +#geL, geR, gmuL, gmuR = 1./2.+sW2, sW2, -1./2.+sW2, sW2 # G_Newton in MeV^-2 GN = 6.70883e-39*1e-6 diff --git a/linx/linx chemical potential testing 4-30.ipynb b/linx/linx chemical potential testing 4-30.ipynb new file mode 100644 index 0000000..2ecac52 --- /dev/null +++ b/linx/linx chemical potential testing 4-30.ipynb @@ -0,0 +1,201 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7e4c18c0-46cd-4c44-8238-de9d3cdf3ea4", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload\n", + "import numpy as np\n", + "import jax.numpy as jnp\n", + "import jax\n", + "from jax import jit, vmap\n", + "import sys\n", + "\n", + "sys.path.append(\"../\")\n", + "import linx.const as const \n", + "from linx.nuclear import NuclearRates\n", + "from linx.background import BackgroundModel\n", + "from linx.abundances import AbundanceModel" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6ab02430-4b31-411f-b10f-6dbf596b11ed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "`\\ /´ |||| |||| ||||| |||| |||| ||||\n", + " /\\_______/\\ |||| |||| ||||||| |||| |||| ||||\n", + " ) __` ´__ ( |||| |||| |||| |||| |||| |||||||\n", + "/ `-|_|-´ \\ |||| |||| |||| |||| ||| ||||||| \n", + "/ (_x_) \\ |||||||||| |||| |||| ||||||| |||| ||||\n", + " ) `-´ ( |||||||||| |||| |||| |||||| |||| ||||\n", + " \n", + "Compiling thermodynamics model...\n" + ] + } + ], + "source": [ + "thermo_model_DNeff = BackgroundModel()\n", + "\n", + "(\n", + " t_vec_ref, a_vec_ref, rho_g_vec, rho_nu_vec, rho_NP_vec, P_NP_vec, Neff_vec \n", + ") = thermo_model_DNeff(0.)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cdcc8520", + "metadata": {}, + "outputs": [], + "source": [ + "network = 'key_PRIMAT_2023'\n", + "# network = 'key_PRIMAT_2018'\n", + "# network = 'key_PArthENoPE'\n", + "# network = 'key_YOF'\n", + "abundance_model = AbundanceModel(NuclearRates(nuclear_net=network))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eef27bb3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C_n_nue (for T_g=8.0, T_nue=8.0, T_numt=8.0, mu_nue=0.0, mu_numt=0.0)= 0.0\n", + "C_n_nue (for T_g=1.0, T_nue=1.0, T_numt=1.0, mu_nue=0.0, mu_numt=0.0)= 0.0\n", + "C_n_nue (for T_g=0.1, T_nue=0.0, T_numt=0.0, mu_nue=0.0, mu_numt=0.0)= 4.1894973347604904e-13\n" + ] + } + ], + "source": [ + "import linx.thermo as thermo\n", + "\n", + "import linx.const as const\n", + "\n", + "me = const.me\n", + "\n", + "mu_nue = [0.0]\n", + "mu_numt = [0.0]\n", + "for mu_nue, mu_numt in zip(mu_nue, mu_numt):\n", + " T_g = [8.0, 1.0, 0.05]\n", + " T_nue = [8.0, 1.0, 0.02]\n", + " T_numt = [8.0, 1.0, 0.02]\n", + " for T_g, T_nue, T_numt in zip(T_g, T_nue, T_numt):\n", + " out = thermo.collision_terms_std(\n", + " T_g=T_g,\n", + " T_nue=T_nue,\n", + " T_numt=T_numt,\n", + " mu_nue=mu_nue,\n", + " mu_numt=mu_numt,\n", + " decoupled=False,\n", + " use_FD=True,\n", + " collision_me=True,\n", + " )\n", + "\n", + " C_rho_nue, C_rho_numu, C_n_nue, C_n_numu = out\n", + " drho_EM_dT_g = thermo.drho_EM_dT_g_std(T_g, me=me)\n", + " drho_nu_dT_nu = thermo.drho_nue_dT_nue_std(T_nue)\n", + "\n", + " # print(\"C_rho_nue (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_rho_nue)\n", + " # print(\"C_rho_numu (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_rho_numu)\n", + " \n", + "\n", + " # print(\"drho_EM/dT_g (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), drho_EM_dT_g)\n", + " # print(\"drho_nu/dT_nu (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), drho_nu_dT_nu)\n", + "\n", + " print(\"C_n_nue (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_n_nue)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f855974c", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "549c1ee5", + "metadata": {}, + "outputs": [], + "source": [ + "plt.loglog(t_vec_ref, Neff_vec, label=\"Neff\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab654250", + "metadata": {}, + "outputs": [], + "source": [ + "plt.loglog(t_vec_ref, rho_nu_vec, label=\"rho_nu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "17d9510f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.1894973347604904e-13\n" + ] + } + ], + "source": [ + "print(C_n_nue)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "871be4bf", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "linx", + "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.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/linx/thermo.py b/linx/thermo.py index ffb94e6..b69141a 100644 --- a/linx/thermo.py +++ b/linx/thermo.py @@ -6,6 +6,7 @@ import jax.lax as lax from jax import grad, vmap, device_put, devices import interpax +from numpy.strings import index import linx.const as const from linx.special_funcs import Li, K1, K2 @@ -1022,13 +1023,14 @@ def collision_terms_std( """ - - f_n, f_a, f_s = lax.cond( +#define a new constant here from miguels code. zero math limit from the data files in miguel's code. + f_n, f_a, f_s, fa3 = lax.cond( decoupled, - lambda _: (0., 0., 0.), + lambda _: (0., 0., 0., 0.), lambda _: lax.cond( - use_FD, lambda _: (0.852, 0.884, 0.829), - lambda _: (1., 1., 1.), 0. + use_FD, lambda _: (0.852, 0.884, 0.829, 0.00318), + lambda _: (1., 1., 1., 0.), + 0. ), 0. ) @@ -1039,13 +1041,20 @@ def collision_terms_std( gmuR = const.gmuR def G(T_1, mu_1, T_2, mu_2): - return ( 32 * f_a * ( T_1**9 * jnp.exp(2 * mu_1 / T_1) - T_2**9 * jnp.exp(2 * mu_2 / T_2) ) - + 56 * f_s * jnp.exp(2 * mu_1 / T_1) * jnp.exp(2 * mu_2 / T_2) *( +#added new term from nudec + + 32 * fa3 * ( + (T_1*T_2)**4.5 + * ( + jnp.exp(2 * mu_2 / T_2) + - jnp.exp(2 * mu_1 / T_1) + ) + ) + + 56 * f_s * jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) *( T_1**4 * T_2**4 * (T_1 - T_2) ) ) @@ -1063,6 +1072,19 @@ def interp_fa2(f_tab): return jnp.interp( me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] ) + + #defined interpolators 3 and 4. + def interp_fa3(f_tab): + index = 3 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) + + def interp_fa4(f_tab): + index = 4 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) def interp_fs1(f_tab): index = 5 @@ -1109,13 +1131,27 @@ def interp_fs2(f_tab): collision_me, interp_fs2, lambda _: 1., f_coeffs ) + f_ann_3 = lax.cond( + collision_me, interp_fa3, lambda _: 0., f_coeffs + ) + f_ann_4 = lax.cond( + collision_me, interp_fa4, lambda _: 0., f_coeffs + ) + return ( # note f_a and f_s are now folded into f_nue_ann/scat 4 * (geL**2 + geR**2) * (32 * f_ann_1 * ( T_1**9 * jnp.exp(2 * mu_1 / T_1) - T_2**9 * jnp.exp(2 * mu_2 / T_2) ) + + 32 * f_ann_3 * ( + (T_1*T_2)**4.5 + * ( + jnp.exp(2 * mu_2 / T_2) + - jnp.exp(2 * mu_1 / T_1) + ) + ) + 56 * f_scat_1 * ( - jnp.exp(2 * mu_1 / T_1) * jnp.exp(2 * mu_2 / T_2) + jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) * T_1**4 * T_2**4 * (T_1 - T_2) ) ) @@ -1124,8 +1160,15 @@ def interp_fs2(f_tab): T_1**9 * jnp.exp(2 * mu_1 / T_1) - T_2**9 * jnp.exp(2 * mu_2 / T_2) ) + + 32 * f_ann_4 * ( + (T_1*T_2)**4.5 + * ( + jnp.exp(2 * mu_2 / T_2) + - jnp.exp(2 * mu_1 / T_1) + ) + ) + 56 * f_scat_2 * ( - jnp.exp(2 * mu_1 / T_1) * jnp.exp(2 * mu_2 / T_2) + jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) * T_1**4 * T_2**4 * (T_1 - T_2) ) ) @@ -1144,6 +1187,18 @@ def interp_fa2(f_tab): return jnp.interp( me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] ) + + def interp_fa3(f_tab): + index = 3 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) + + def interp_fa4(f_tab): + index = 4 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) def interp_fs1(f_tab): index = 5 @@ -1190,24 +1245,45 @@ def interp_fs2(f_tab): collision_me, interp_fs2, lambda _: 1., f_coeffs ) - return ( # f_s, f_a now folded into f_ann and f_scat - 4 * (gmuL**2 + gmuR**2) * (32 * f_ann_1 * ( - T_1**9 * jnp.exp(2 * mu_1 / T_1) + f_ann_3 = lax.cond( + collision_me, interp_fa3, lambda _: 0., f_coeffs + ) + f_ann_4 = lax.cond( + collision_me, interp_fa4, lambda _: 0., f_coeffs + ) + # f_s, f_a now folded into f_ann and f_scat + return ( + (gmuL**2 + gmuR**2) * 32 * f_ann_1 * ( + T_1**9 * jnp.exp(2 * mu_1 / T_1) - T_2**9 * jnp.exp(2 * mu_2 / T_2) - ) + ) + + 32 * f_ann_3 * ( + (T_1*T_2)**4.5 + * ( + jnp.exp(2 * mu_2 / T_2) + - jnp.exp(2 * mu_1 / T_1) + ) + 56 * f_scat_1 * ( - jnp.exp(2 * mu_1 / T_1) * jnp.exp(2 * mu_2 / T_2) + jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) * T_1**4 * T_2**4 * (T_1 - T_2) ) ) # new terms (previously baked into tabulated rates) - + 4 * gmuL*gmuR * (f_ann_2 * 32 * ( - T_1**9 * jnp.exp(2 * mu_1 / T_1) - - T_2**9 * jnp.exp(2 * mu_2 / T_2) + + 4 * gmuL*gmuR * ( + f_ann_2 * 32 * ( + T_1**9 * jnp.exp(2 * mu_1 / T_1) + - T_2**9 * jnp.exp(2 * mu_2 / T_2) ) - + 56 * f_scat_2 * ( - jnp.exp(2 * mu_1 / T_1) * jnp.exp(2 * mu_2 / T_2) - * T_1**4 * T_2**4 * (T_1 - T_2) + + 32 * f_ann_4 * ( + (T_1*T_2)**4.5 + * ( + jnp.exp(2 * mu_2 / T_2) + - jnp.exp(2 * mu_1 / T_1) + ) + + 56 * f_scat_2 * ( + jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) + * T_1**4 * T_2**4 * (T_1 - T_2) + ) ) ) ) From bf2fcb1bc4e401e607b3cc236f4396b7d33a038e Mon Sep 17 00:00:00 2001 From: Grace Perkins Date: Mon, 31 Aug 2026 15:35:45 -0400 Subject: [PATCH 2/7] changes to collision_terms_std --- .vscode/settings.json | 9 +- linx/background.py | 14 +- ...linx chemical potential testing 4-30.ipynb | 278 +++++++++++++--- linx/thermo.py | 301 ++++++++++-------- 4 files changed, 435 insertions(+), 167 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 4b5a294..191da9b 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,4 +1,11 @@ { "python-envs.defaultEnvManager": "ms-python.python:conda", - "python-envs.defaultPackageManager": "ms-python.python:conda" + "python-envs.defaultPackageManager": "ms-python.python:conda", + "python-envs.pythonProjects": [ + { + "path": ".", + "envManager": "ms-python.python:conda", + "packageManager": "ms-python.python:conda" + } + ] } \ No newline at end of file diff --git a/linx/background.py b/linx/background.py index 404fce5..4e07c21 100644 --- a/linx/background.py +++ b/linx/background.py @@ -242,7 +242,7 @@ def dY(self, t, Y, args): H = thermo.Hubble(rho_EM + rho_nu + rho_extra) - C_rho_nue, C_rho_numu, _, _ = thermo.collision_terms_std( + C_rho_nue, C_rho_numu, C_n_nue, C_n_numu = thermo.collision_terms_std( T_g, T_nu, T_nu, me=me, decoupled=self.decoupled, use_FD=self.use_FD, collision_me=self.collision_me ) @@ -252,4 +252,16 @@ def dY(self, t, Y, args): dT_g_dt = drho_EM_dt / drho_EM_dT_g dT_nu_dt = drho_nu_dt / drho_nu_dT_nu + #P_e = thermo.rho_nue_std(T_g, me=me) / 3 + #dndt_e = C_n_nue(T_g, T_nu, T_nu, me=me, decoupled=self.decoupled, use_FD=self.use_FD, collision_me=self.collision_me) + + #dmue_dt = -(-3.* H *( (thermo.rho_nue_std+P_e) * thermo.dn_nue_dT_nue_std - thermo.n_nue_std * thermo.drho_nue_dT_nue_std) + thermo.dn_nue_dT_nue_std * thermo.drho_nue_dT_nue_std - thermo.drho_nue_dT_nue_std * dndt_e )/(thermo.dn_nue_dmu_nue_std * thermo.drho_nue_dT_nue_std - thermo.dn_nue_dT_nue_std * thermo.drho_nue_dmu_nue_std) + + + #P_mu = thermo.rho_numt_std(T_nu, me=me) / 3 + #dndt_mu = C_n_numu(T_g, T_nu, T_nu, me=me, decoupled=self.decoupled, use_FD=self.use_FD, collision_me=self.collision_me) + + #dmunu_dt = -(-3.*H*( (thermo.rho_numt_std+P_mu)* thermo.dn_numt_dT_numt_std - thermo.n_numt.std * thermo.drho_numt_dT_numt_std) + thermo.dn_numt_dT_numt_std * thermo.drho_numt_dT_numt_std - thermo.drho_numt_dT_numt_std * dndt_mu )/(thermo.dn_numt_dmu_numt_std * thermo.drho_numt_dT_numt_std - thermo.dn_numt_dT_numt_std * thermo.drho_numt_dmu_numt_std) + return H, dT_g_dt, dT_nu_dt + #return H, dT_g_dt, dT_nu_dt, dmue_dt, dmunu_dt diff --git a/linx/linx chemical potential testing 4-30.ipynb b/linx/linx chemical potential testing 4-30.ipynb index 2ecac52..5607e5f 100644 --- a/linx/linx chemical potential testing 4-30.ipynb +++ b/linx/linx chemical potential testing 4-30.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "7e4c18c0-46cd-4c44-8238-de9d3cdf3ea4", "metadata": {}, "outputs": [], @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "6ab02430-4b31-411f-b10f-6dbf596b11ed", "metadata": {}, "outputs": [ @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "cdcc8520", "metadata": {}, "outputs": [], @@ -67,31 +67,32 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "eef27bb3", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "C_n_nue (for T_g=8.0, T_nue=8.0, T_numt=8.0, mu_nue=0.0, mu_numt=0.0)= 0.0\n", - "C_n_nue (for T_g=1.0, T_nue=1.0, T_numt=1.0, mu_nue=0.0, mu_numt=0.0)= 0.0\n", - "C_n_nue (for T_g=0.1, T_nue=0.0, T_numt=0.0, mu_nue=0.0, mu_numt=0.0)= 4.1894973347604904e-13\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "import linx.thermo as thermo\n", - "\n", + "import matplotlib.pyplot as plt\n", "import linx.const as const\n", "\n", "me = const.me\n", "\n", - "mu_nue = [0.0]\n", - "mu_numt = [0.0]\n", + "mu_nue = [0.0, 0.1, 1.0]\n", + "mu_numt = [0.0, 0.1, 1.0]\n", "for mu_nue, mu_numt in zip(mu_nue, mu_numt):\n", - " T_g = [8.0, 1.0, 0.05]\n", + " T_g = thermo.T_g(rho_g_vec)\n", " T_nue = [8.0, 1.0, 0.02]\n", " T_numt = [8.0, 1.0, 0.02]\n", " for T_g, T_nue, T_numt in zip(T_g, T_nue, T_numt):\n", @@ -110,68 +111,271 @@ " drho_EM_dT_g = thermo.drho_EM_dT_g_std(T_g, me=me)\n", " drho_nu_dT_nu = thermo.drho_nue_dT_nue_std(T_nue)\n", "\n", - " # print(\"C_rho_nue (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_rho_nue)\n", - " # print(\"C_rho_numu (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_rho_numu)\n", + " plt.plot(T_nue, T_g, label=r\"$C_{\\rho_{\\nu_e}}$\")\n", + "\n", + " #print(\"C_rho_nue (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_rho_nue)\n", + " #print(\"C_rho_numu (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_rho_numu)\n", " \n", "\n", - " # print(\"drho_EM/dT_g (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), drho_EM_dT_g)\n", - " # print(\"drho_nu/dT_nu (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), drho_nu_dT_nu)\n", + " #print(\"drho_EM/dT_g (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), drho_EM_dT_g)\n", + " #print(\"drho_nu/dT_nu (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), drho_nu_dT_nu)\n", "\n", - " print(\"C_n_nue (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_n_nue)" + " #print(\"C_n_nue (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_n_nue)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "f855974c", + "execution_count": 18, + "id": "871be4bf", "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt" + "#thermo quantities (neutrino temp, photon energy density) versus photon temperature. choose nonzero mus\n" ] }, { "cell_type": "code", - "execution_count": null, - "id": "549c1ee5", + "execution_count": 23, + "id": "511383cf", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished constructing interpolation functions. \n", + " solve system from T_ini = 10.000 to T_fin = 0.009 [MeV]\n", + " --> t_ini = 7.39E-03 [s] to t_fin = 1.63E+04 [s]\n", + "\n", + "Progress: 100.000 %" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "plt.loglog(t_vec_ref, Neff_vec, label=\"Neff\")" + "import sys\n", + "sys.path.append(r\"C:\\Users\\grace\\nudec_BSM\\BasicModules_source\")\n", + "import nudec_v2\n", + "nudec = nudec_v2.NuDec()\n", + "\n", + "import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from importlib import reload\n", + "\n", + "#import BasicModules_source.nudec_v2\n", + "\n", + "#nudec_source = reload(BasicModules_source.nudec_v2)\n", + "\n", + "\n", + "T_g = thermo.T_g(rho_g_vec)\n", + "plt.loglog(T_g, rho_g_vec, label=r\"$\\rho_\\gamma$\")\n", + "\n", + "\n", + "plt.title(\"T_g vs. rho_g\")\n", + "plt.xlabel(\"T_g (MeV)\")\n", + "plt.ylabel(\"rho_g (MeV^4)\")\n", + "\n", + "t_nudec, y_nudec = nudec.evolve()\n", + "\n", + "T_g_nudec = y_nudec[0]\n", + "\n", + "rho_g_nudec = (np.pi**2 / 15) * T_g_nudec**4\n", + "\n", + "plt.loglog(T_g_nudec, rho_g_nudec, label=\"NuDec\")" ] }, { "cell_type": "code", - "execution_count": null, - "id": "ab654250", + "execution_count": 71, + "id": "4d42b814", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished constructing interpolation functions. rho_nue_std= [Array(0.02538031, dtype=float64, weak_type=True), Array(0.03154887, dtype=float64, weak_type=True), Array(0.04960956, dtype=float64, weak_type=True), Array(0.08379177, dtype=float64, weak_type=True), Array(0.140427, dtype=float64, weak_type=True), Array(0.22753964, dtype=float64, weak_type=True), Array(0.35466176, dtype=float64, weak_type=True), Array(0.53276147, dtype=float64, weak_type=True), Array(0.77421426, dtype=float64, weak_type=True), Array(1.09279044, dtype=float64, weak_type=True)]\n", + "rho_nue_nudec= [np.float64(0.025380307425122914), np.float64(0.03154887023860299), np.float64(0.049609552386488426), np.float64(0.0837917410801468), np.float64(0.1404269050871636), np.float64(0.22753941648258197), np.float64(0.3546612930175843), np.float64(0.5327606213566303), np.float64(0.7742128242095982), np.float64(1.0927881535123134)]\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'rho_nue vs. T_nue for mu_nue=1')" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "plt.loglog(t_vec_ref, rho_nu_vec, label=\"rho_nu\")" + "import sys\n", + "sys.path.append(r\"C:\\Users\\grace\\nudec_BSM\\BasicModules_source\")\n", + "import nudec_v2\n", + "nudec = nudec_v2.NuDec()\n", + "\n", + "import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from importlib import reload\n", + "\n", + "mu=1\n", + "\n", + "T_nue = np.arange(0.01, 1, 0.1)\n", + "rho_nue_std = []\n", + "rho_nue_nudec = []\n", + "for T in T_nue:\n", + " rho_nue_linx = thermo.rho_nue_std(T, mu)\n", + " rho_nue_nudecbsm = nudec.thermo.Rho_FD(T, mu)\n", + " rho_nue_std.append(rho_nue_linx)\n", + " rho_nue_nudec.append(rho_nue_nudecbsm)\n", + "print(\"rho_nue_std=\", rho_nue_std)\n", + "print(\"rho_nue_nudec=\", rho_nue_nudec)\n", + "\n", + "plt.loglog(T_nue, rho_nue_std, label=\"rho_nue_std\")\n", + "plt.loglog(T_nue, rho_nue_nudec, label=\"rho_nue_nudec\")\n", + "\n", + "plt.xlabel(\"T_nue (MeV)\")\n", + "plt.ylabel(\"rho_nue (MeV^4)\")\n", + "plt.title(\"rho_nue vs. T_nue for mu_nue={}\".format(mu))" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "17d9510f", + "execution_count": 83, + "id": "bea7f67d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "4.1894973347604904e-13\n" + "rho_nue_linx= [0.02538031 0.03154887 0.04960956 0.08379177 0.140427 0.22753964\n", + " 0.35466176 0.53276147 0.77421426 1.09279044]\n", + "rho_nue_nudec= [0.02538031 0.03154887 0.04960955 0.08379174 0.14042691 0.22753942\n", + " 0.35466129 0.53276062 0.77421282 1.09278815]\n", + "rho_nue_residuals= [1.31626872e-12 1.55039714e-08 1.30968819e-07 3.68215112e-07\n", + " 6.72266008e-07 9.93299208e-07 1.30425018e-06 1.59349267e-06\n", + " 1.85788175e-06 2.09656629e-06]\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "print(C_n_nue)" + "\n", + "print(\"rho_nue_linx=\", np.array(rho_nue_std))\n", + "print(\"rho_nue_nudec=\", np.array(rho_nue_nudec))\n", + "\n", + "\n", + "\n", + "rho_nue_difference = np.array(rho_nue_std) - np.array(rho_nue_nudec) \n", + "rho_nue_residuals = rho_nue_difference / np.array(rho_nue_nudec)\n", + "print(\"rho_nue_residuals=\", rho_nue_residuals)\n", + "plt.loglog(T_nue, rho_nue_residuals, label=\"residuals\", color='blue', linestyle='dotted')\n", + "plt.xlabel(\"T_nue (MeV)\")\n", + "plt.ylabel(\"residuals\")\n", + "plt.title(\"residuals of rho_nue vs. T_nue for mu_nue={}\".format(mu))\n", + "plt.show()\n", + "\n", + "T_nue_log = np.log10(T_nue)\n", + "rho_nue_residuals_log = np.log10(rho_nue_residuals)\n", + "\n", + "plt.plot(T_nue_log, rho_nue_residuals_log, label=\"rho_nue_std, reconstructed log plot\",color='green', linestyle='dashed')\n", + "plt.xlabel(\"T_nue (MeV)\")\n", + "plt.ylabel(\"rho_nue_residuals (MeV^4)\")\n", + "plt.title(\"rho_nue vs. T_nue for mu_nue={}\".format(mu))\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "98e368ce", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'rho_nue vs. T_nue for mu_nue=1, linear plot')" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.loglog(T_nue, rho_nue_residuals, label=\"rho_nue_std, reconstructed\",color='red', linestyle='dashed')\n", + "plt.xlabel(\"T_nue (MeV)\")\n", + "plt.ylabel(\"rho_nue_residuals (MeV^4)\")\n", + "plt.title(\"rho_nue vs. T_nue for mu_nue={}, linear plot\".format(mu))" ] }, { "cell_type": "code", "execution_count": null, - "id": "871be4bf", + "id": "2fccbf7f", "metadata": {}, "outputs": [], "source": [] @@ -179,7 +383,7 @@ ], "metadata": { "kernelspec": { - "display_name": "linx", + "display_name": "Python 3", "language": "python", "name": "python3" }, diff --git a/linx/thermo.py b/linx/thermo.py index b69141a..9ca2f56 100644 --- a/linx/thermo.py +++ b/linx/thermo.py @@ -6,7 +6,6 @@ import jax.lax as lax from jax import grad, vmap, device_put, devices import interpax -from numpy.strings import index import linx.const as const from linx.special_funcs import Li, K1, K2 @@ -1023,15 +1022,14 @@ def collision_terms_std( """ -#define a new constant here from miguels code. zero math limit from the data files in miguel's code. - f_n, f_a, f_s, fa3 = lax.cond( - decoupled, - lambda _: (0., 0., 0., 0.), + + f_n, f_a, f_s, f_a3, f_n3 = lax.cond( + decoupled, + lambda _: (0., 0., 0., 0., 0.), lambda _: lax.cond( - use_FD, lambda _: (0.852, 0.884, 0.829, 0.00318), - lambda _: (1., 1., 1., 0.), - 0. - ), + use_FD, lambda _: (0.852, 0.884, 0.829, 0.031837, 0.041088), + lambda _: (1., 1., 1., 0., 0.), 0. + ), 0. ) @@ -1041,21 +1039,25 @@ def collision_terms_std( gmuR = const.gmuR def G(T_1, mu_1, T_2, mu_2): + return ( 32 * f_a * ( T_1**9 * jnp.exp(2 * mu_1 / T_1) - T_2**9 * jnp.exp(2 * mu_2 / T_2) ) -#added new term from nudec - + 32 * fa3 * ( - (T_1*T_2)**4.5 - * ( - jnp.exp(2 * mu_2 / T_2) - - jnp.exp(2 * mu_1 / T_1) - ) + + 32 * f_a3 * (T_1*T_2)**4.5 * (jnp.exp(2 * mu_2 / T_2) - jnp.exp(2 * mu_1 / T_1)) + + 56 * f_s * jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) *(T_1**4 * T_2**4 * (T_1 - T_2)) + ) + + def N(T_1, mu_1, T_2, mu_2): + + return ( + f_n * ( + T_1**8 * jnp.exp(2 * mu_1 / T_1) + - T_2**8 * jnp.exp(2 * mu_2 / T_2) ) - + 56 * f_s * jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) *( - T_1**4 * T_2**4 * (T_1 - T_2) + + f_n3 * (T_1*T_2)**4 * ( + jnp.exp(2 * mu_2 / T_2) - jnp.exp(2 * mu_1 / T_1) ) ) @@ -1072,8 +1074,7 @@ def interp_fa2(f_tab): return jnp.interp( me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] ) - - #defined interpolators 3 and 4. + def interp_fa3(f_tab): index = 3 return jnp.interp( @@ -1084,7 +1085,7 @@ def interp_fa4(f_tab): index = 4 return jnp.interp( me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] - ) + ) def interp_fs1(f_tab): index = 5 @@ -1097,25 +1098,8 @@ def interp_fs2(f_tab): return jnp.interp( me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] ) -# def interp_f(f_tab): -# # Tables have boundary values 0.0 (low T) and 1.0 (high T) -# return interpax.interp1d( -# T_1, f_tab[:,0], f_tab[:,1], extrap=(0.0, 1.0) -# ) - - - # def interp_f(f_tab): - - # return jnp.interp( - # T_1, f_tab[:,0], f_tab[:,1], left=f_tab[0,1], right=f_tab[-1,1] - # ) - - # f_nue_ann = lax.cond( - # collision_me, interp_f, lambda _: 1., f_nue_ann_tab - # ) - # f_nue_scat = lax.cond( - # collision_me, interp_f, lambda _: 1., f_nue_scat_tab - # ) + + f_ann_1 = lax.cond( collision_me, interp_fa1, lambda _: 1., f_coeffs @@ -1130,46 +1114,86 @@ def interp_fs2(f_tab): f_scat_2 = lax.cond( collision_me, interp_fs2, lambda _: 1., f_coeffs ) - f_ann_3 = lax.cond( collision_me, interp_fa3, lambda _: 0., f_coeffs ) f_ann_4 = lax.cond( collision_me, interp_fa4, lambda _: 0., f_coeffs ) - + return ( # note f_a and f_s are now folded into f_nue_ann/scat 4 * (geL**2 + geR**2) * (32 * f_ann_1 * ( T_1**9 * jnp.exp(2 * mu_1 / T_1) - T_2**9 * jnp.exp(2 * mu_2 / T_2) - ) - + 32 * f_ann_3 * ( - (T_1*T_2)**4.5 - * ( - jnp.exp(2 * mu_2 / T_2) - - jnp.exp(2 * mu_1 / T_1) - ) - ) - + 56 * f_scat_1 * ( - jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) - * T_1**4 * T_2**4 * (T_1 - T_2) - ) + ) + + 32 * f_ann_3 * (T_1*T_2)**4.5 * (jnp.exp(2 * mu_2 / T_2) - jnp.exp(2 * mu_1 / T_1)) + + 56 * f_scat_1 * (jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2)* T_1**4 * T_2**4 * (T_1 - T_2)) ) # new terms (previously baked into tabulated rates) + 4 * geL*geR * (f_ann_2 * 32 * ( T_1**9 * jnp.exp(2 * mu_1 / T_1) - T_2**9 * jnp.exp(2 * mu_2 / T_2) ) - + 32 * f_ann_4 * ( - (T_1*T_2)**4.5 - * ( - jnp.exp(2 * mu_2 / T_2) - - jnp.exp(2 * mu_1 / T_1) - ) - ) - + 56 * f_scat_2 * ( - jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) - * T_1**4 * T_2**4 * (T_1 - T_2) + + 32 * f_ann_4 * (T_1*T_2)**4.5 * (jnp.exp(2*mu_2/T_2) - jnp.exp(2*mu_1/T_1)) + + 56 * f_scat_2 * (jnp.exp(mu_1/T_1) * jnp.exp(mu_2/T_2) * T_1**4 * T_2**4 * (T_1-T_2)) + ) + ) + def N_nue_with_me(T_1, mu_1, T_2, mu_2, me): + + def interp_fn1(f_tab): + index = 9 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) + + def interp_fn2(f_tab): + index = 10 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) + + def interp_fn3(f_tab): + index = 11 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) + + def interp_fn4(f_tab): + index = 12 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) + + f_num_1 = lax.cond( + collision_me, interp_fn1, lambda _: 1., f_coeffs + ) + f_num_2 = lax.cond( + collision_me, interp_fn2, lambda _: 0., f_coeffs + ) + f_num_3 = lax.cond( + collision_me, interp_fn3, lambda _: 0., f_coeffs + ) + f_num_4 = lax.cond( + collision_me, interp_fn4, lambda _: 0., f_coeffs + ) + + return ( + 4 * (geL**2 + geR**2) * ( + f_num_1 * ( + T_1**8 * jnp.exp(2 * mu_1 / T_1) + - T_2**8 * jnp.exp(2 * mu_2 / T_2) + ) + + f_num_3 * (T_1*T_2)**4 * ( + jnp.exp(2 * mu_2 / T_2) - jnp.exp(2 * mu_1 / T_1) + ) + ) + + 4 * geL*geR * ( + f_num_2 * ( + T_1**8 * jnp.exp(2 * mu_1 / T_1) + - T_2**8 * jnp.exp(2 * mu_2 / T_2) + ) + + f_num_4 * (T_1*T_2)**4 * ( + jnp.exp(2 * mu_2 / T_2) - jnp.exp(2 * mu_1 / T_1) ) ) ) @@ -1187,7 +1211,6 @@ def interp_fa2(f_tab): return jnp.interp( me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] ) - def interp_fa3(f_tab): index = 3 return jnp.interp( @@ -1210,26 +1233,7 @@ def interp_fs2(f_tab): index = 6 return jnp.interp( me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index]) -# def G_numt_with_me(T_1, mu_1, T_2, mu_2): -# def interp_f(f_tab): -# # Tables have boundary values 0.0 (low T) and 1.0 (high T) -# return interpax.interp1d( -# T_1, f_tab[:,0], f_tab[:,1], extrap=(0.0, 1.0) -# ) - - # def interp_f(f_tab): - - # return jnp.interp( - # T_1, f_tab[:,0], f_tab[:,1], left=f_tab[0,1], right=f_tab[-1,1] - # ) - - # f_numt_ann = lax.cond( - # collision_me, interp_f, lambda _: 1., f_numu_ann_tab - # ) - # f_numt_scat = lax.cond( - # collision_me, interp_f, lambda _: 1., f_numu_scat_tab - # ) f_ann_1 = lax.cond( collision_me, interp_fa1, lambda _: 1., f_coeffs @@ -1244,50 +1248,89 @@ def interp_fs2(f_tab): f_scat_2 = lax.cond( collision_me, interp_fs2, lambda _: 1., f_coeffs ) - f_ann_3 = lax.cond( collision_me, interp_fa3, lambda _: 0., f_coeffs ) f_ann_4 = lax.cond( collision_me, interp_fa4, lambda _: 0., f_coeffs ) - # f_s, f_a now folded into f_ann and f_scat - return ( - (gmuL**2 + gmuR**2) * 32 * f_ann_1 * ( - T_1**9 * jnp.exp(2 * mu_1 / T_1) + return ( # f_s, f_a now folded into f_ann and f_scat + 4 * (gmuL**2 + gmuR**2) * (32 * f_ann_1 * ( + T_1**9 * jnp.exp(2 * mu_1 / T_1) - T_2**9 * jnp.exp(2 * mu_2 / T_2) + ) + + 32 * f_ann_3 * (T_1*T_2)**4.5 * (jnp.exp(2 * mu_2 / T_2) - jnp.exp(2 * mu_1 / T_1)) + + 56 * f_scat_1 * (jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2)* T_1**4 * T_2**4 * (T_1 - T_2)) + ) + # new terms (previously baked into tabulated rates) + + 4 * gmuL*gmuR * (f_ann_2 * 32 * ( + T_1**9 * jnp.exp(2 * mu_1 / T_1) + - T_2**9 * jnp.exp(2 * mu_2 / T_2) + ) + + 32 * f_ann_4 * (T_1*T_2)**4.5 * (jnp.exp(2 * mu_2 / T_2) - jnp.exp(2 * mu_1 / T_1)) + + 56 * f_scat_2 * (jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) * T_1**4 * T_2**4 * (T_1 - T_2)) + ) + ) + + def N_numt_with_me(T_1, mu_1, T_2, mu_2, me): + + def interp_fn1(f_tab): + index = 9 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) + + def interp_fn2(f_tab): + index = 10 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) + + def interp_fn3(f_tab): + index = 11 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] + ) + + def interp_fn4(f_tab): + index = 12 + return jnp.interp( + me/T_1, f_tab[:,0], f_tab[:,index], left=f_tab[0,index], right=f_tab[-1,index] ) - + 32 * f_ann_3 * ( - (T_1*T_2)**4.5 - * ( - jnp.exp(2 * mu_2 / T_2) - - jnp.exp(2 * mu_1 / T_1) + + f_num_1 = lax.cond( + collision_me, interp_fn1, lambda _: 1., f_coeffs + ) + f_num_2 = lax.cond( + collision_me, interp_fn2, lambda _: 0., f_coeffs + ) + f_num_3 = lax.cond( + collision_me, interp_fn3, lambda _: 0., f_coeffs + ) + f_num_4 = lax.cond( + collision_me, interp_fn4, lambda _: 0., f_coeffs + ) + + return ( + 4 * (gmuL**2 + gmuR**2) * ( + f_num_1 * ( + T_1**8 * jnp.exp(2 * mu_1 / T_1) + - T_2**8 * jnp.exp(2 * mu_2 / T_2) ) - + 56 * f_scat_1 * ( - jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) - * T_1**4 * T_2**4 * (T_1 - T_2) + + f_num_3 * (T_1*T_2)**4 * ( + jnp.exp(2 * mu_2 / T_2) - jnp.exp(2 * mu_1 / T_1) ) ) - # new terms (previously baked into tabulated rates) + 4 * gmuL*gmuR * ( - f_ann_2 * 32 * ( - T_1**9 * jnp.exp(2 * mu_1 / T_1) - - T_2**9 * jnp.exp(2 * mu_2 / T_2) + f_num_2 * ( + T_1**8 * jnp.exp(2 * mu_1 / T_1) + - T_2**8 * jnp.exp(2 * mu_2 / T_2) ) - + 32 * f_ann_4 * ( - (T_1*T_2)**4.5 - * ( - jnp.exp(2 * mu_2 / T_2) - - jnp.exp(2 * mu_1 / T_1) - ) - + 56 * f_scat_2 * ( - jnp.exp(mu_1 / T_1) * jnp.exp(mu_2 / T_2) - * T_1**4 * T_2**4 * (T_1 - T_2) - ) + + f_num_4 * (T_1*T_2)**4 * ( + jnp.exp(2 * mu_2 / T_2) - jnp.exp(2 * mu_1 / T_1) ) ) ) - # Units MeV^4 s^-1 C_rho_nue = const.GF**2 / jnp.pi**5 * ( # prev coeff now in G def G_nue_with_me(T_g, 0., T_nue, mu_nue, me) @@ -1301,23 +1344,25 @@ def interp_fs2(f_tab): ) / const.hbar # Units MeV^3 s^-1 - C_n_nue = 8 * f_n * const.GF**2 / jnp.pi**5 * ( - 4 * (geL**2 + geR**2) - * (T_g**8 - T_nue**8 * jnp.exp(2 * mu_nue / T_nue)) - + 2 * ( - T_numt**8 * jnp.exp(2 * mu_numt / T_numt) - - T_nue**8 * jnp.exp(2 * mu_nue / T_nue) - ) - ) / const.hbar + C_n_nue = lax.cond( + decoupled, + lambda _: 0., + lambda _: 8 * const.GF**2 / jnp.pi**5 * ( + N_nue_with_me(T_g, 0., T_nue, mu_nue, me) + + 2 * N(T_numt, mu_numt, T_nue, mu_nue) + ) / const.hbar, + 0. + ) # Units MeV^3 s^-1 - C_n_numu = 8 * f_n * const.GF**2 / jnp.pi**5 * ( - 4 * (gmuL**2 + gmuR**2) - * (T_g**8 - T_nue**8 * jnp.exp(2 * mu_numt / T_numt)) - - ( - T_numt**8 * jnp.exp(2 * mu_numt / T_numt) - - T_nue**8 * jnp.exp(2 * mu_nue / T_nue) - ) - ) / const.hbar + C_n_numu = lax.cond( + decoupled, + lambda _: 0., + lambda _: 8 * const.GF**2 / jnp.pi**5 * ( + N_numt_with_me(T_g, 0., T_numt, mu_numt, me) + - N(T_numt, mu_numt, T_nue, mu_nue) + ) / const.hbar, + 0. + ) return C_rho_nue, C_rho_numu, C_n_nue, C_n_numu \ No newline at end of file From e70acc0f3fd51b8388634ef1e5f2ef461ecee8f4 Mon Sep 17 00:00:00 2001 From: cgiovanetti <52010580+cgiovanetti@users.noreply.github.com> Date: Mon, 31 Aug 2026 13:23:26 -0700 Subject: [PATCH 3/7] Delete .vscode directory --- .vscode/settings.json | 11 ----------- 1 file changed, 11 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 191da9b..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "python-envs.defaultEnvManager": "ms-python.python:conda", - "python-envs.defaultPackageManager": "ms-python.python:conda", - "python-envs.pythonProjects": [ - { - "path": ".", - "envManager": "ms-python.python:conda", - "packageManager": "ms-python.python:conda" - } - ] -} \ No newline at end of file From cc6ac60fc84668e239f809ea9fdeb7f7daa73db6 Mon Sep 17 00:00:00 2001 From: cgiovanetti <52010580+cgiovanetti@users.noreply.github.com> Date: Mon, 31 Aug 2026 13:24:26 -0700 Subject: [PATCH 4/7] Delete linx/chemical potential testing.ipynb --- linx/chemical potential testing.ipynb | 68 --------------------------- 1 file changed, 68 deletions(-) delete mode 100644 linx/chemical potential testing.ipynb diff --git a/linx/chemical potential testing.ipynb b/linx/chemical potential testing.ipynb deleted file mode 100644 index 2024abe..0000000 --- a/linx/chemical potential testing.ipynb +++ /dev/null @@ -1,68 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "7e4c18c0-46cd-4c44-8238-de9d3cdf3ea4", - "metadata": {}, - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'equinox'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 11\u001b[39m\n\u001b[32m 7\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m sys\n\u001b[32m 8\u001b[39m \n\u001b[32m 9\u001b[39m sys.path.append(\u001b[33m\"../\"\u001b[39m)\n\u001b[32m 10\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m linx.const \u001b[38;5;28;01mas\u001b[39;00m const\n\u001b[32m---> \u001b[39m\u001b[32m11\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m linx.nuclear \u001b[38;5;28;01mimport\u001b[39;00m NuclearRates\n\u001b[32m 12\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m linx.background \u001b[38;5;28;01mimport\u001b[39;00m BackgroundModel\n\u001b[32m 13\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m linx.abundances \u001b[38;5;28;01mimport\u001b[39;00m AbundanceModel\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\LINX-original\\linx\\..\\linx\\nuclear.py:2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjax\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjnp\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mequinox\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01meqx\u001b[39;00m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01minterpax\u001b[39;00m\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mlinx\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mconst\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mconst\u001b[39;00m\n", - "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'equinox'" - ] - } - ], - "source": [ - "%load_ext autoreload\n", - "%autoreload\n", - "import numpy as np\n", - "import jax.numpy as jnp\n", - "import jax\n", - "from jax import jit, vmap\n", - "import sys\n", - "\n", - "sys.path.append(\"../\")\n", - "import linx.const as const \n", - "from linx.nuclear import NuclearRates\n", - "from linx.background import BackgroundModel\n", - "from linx.abundances import AbundanceModel" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6ab02430-4b31-411f-b10f-6dbf596b11ed", - "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.11.15" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 9b61c1b21682ec163142f4d56ede3627058b0df7 Mon Sep 17 00:00:00 2001 From: cgiovanetti <52010580+cgiovanetti@users.noreply.github.com> Date: Mon, 31 Aug 2026 13:25:47 -0700 Subject: [PATCH 5/7] Delete linx/linx chemical potential testing 4-30.ipynb --- ...linx chemical potential testing 4-30.ipynb | 405 ------------------ 1 file changed, 405 deletions(-) delete mode 100644 linx/linx chemical potential testing 4-30.ipynb diff --git a/linx/linx chemical potential testing 4-30.ipynb b/linx/linx chemical potential testing 4-30.ipynb deleted file mode 100644 index 5607e5f..0000000 --- a/linx/linx chemical potential testing 4-30.ipynb +++ /dev/null @@ -1,405 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "id": "7e4c18c0-46cd-4c44-8238-de9d3cdf3ea4", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload\n", - "import numpy as np\n", - "import jax.numpy as jnp\n", - "import jax\n", - "from jax import jit, vmap\n", - "import sys\n", - "\n", - "sys.path.append(\"../\")\n", - "import linx.const as const \n", - "from linx.nuclear import NuclearRates\n", - "from linx.background import BackgroundModel\n", - "from linx.abundances import AbundanceModel" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "6ab02430-4b31-411f-b10f-6dbf596b11ed", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "`\\ /´ |||| |||| ||||| |||| |||| ||||\n", - " /\\_______/\\ |||| |||| ||||||| |||| |||| ||||\n", - " ) __` ´__ ( |||| |||| |||| |||| |||| |||||||\n", - "/ `-|_|-´ \\ |||| |||| |||| |||| ||| ||||||| \n", - "/ (_x_) \\ |||||||||| |||| |||| ||||||| |||| ||||\n", - " ) `-´ ( |||||||||| |||| |||| |||||| |||| ||||\n", - " \n", - "Compiling thermodynamics model...\n" - ] - } - ], - "source": [ - "thermo_model_DNeff = BackgroundModel()\n", - "\n", - "(\n", - " t_vec_ref, a_vec_ref, rho_g_vec, rho_nu_vec, rho_NP_vec, P_NP_vec, Neff_vec \n", - ") = thermo_model_DNeff(0.)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "cdcc8520", - "metadata": {}, - "outputs": [], - "source": [ - "network = 'key_PRIMAT_2023'\n", - "# network = 'key_PRIMAT_2018'\n", - "# network = 'key_PArthENoPE'\n", - "# network = 'key_YOF'\n", - "abundance_model = AbundanceModel(NuclearRates(nuclear_net=network))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "eef27bb3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import linx.thermo as thermo\n", - "import matplotlib.pyplot as plt\n", - "import linx.const as const\n", - "\n", - "me = const.me\n", - "\n", - "mu_nue = [0.0, 0.1, 1.0]\n", - "mu_numt = [0.0, 0.1, 1.0]\n", - "for mu_nue, mu_numt in zip(mu_nue, mu_numt):\n", - " T_g = thermo.T_g(rho_g_vec)\n", - " T_nue = [8.0, 1.0, 0.02]\n", - " T_numt = [8.0, 1.0, 0.02]\n", - " for T_g, T_nue, T_numt in zip(T_g, T_nue, T_numt):\n", - " out = thermo.collision_terms_std(\n", - " T_g=T_g,\n", - " T_nue=T_nue,\n", - " T_numt=T_numt,\n", - " mu_nue=mu_nue,\n", - " mu_numt=mu_numt,\n", - " decoupled=False,\n", - " use_FD=True,\n", - " collision_me=True,\n", - " )\n", - "\n", - " C_rho_nue, C_rho_numu, C_n_nue, C_n_numu = out\n", - " drho_EM_dT_g = thermo.drho_EM_dT_g_std(T_g, me=me)\n", - " drho_nu_dT_nu = thermo.drho_nue_dT_nue_std(T_nue)\n", - "\n", - " plt.plot(T_nue, T_g, label=r\"$C_{\\rho_{\\nu_e}}$\")\n", - "\n", - " #print(\"C_rho_nue (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_rho_nue)\n", - " #print(\"C_rho_numu (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_rho_numu)\n", - " \n", - "\n", - " #print(\"drho_EM/dT_g (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), drho_EM_dT_g)\n", - " #print(\"drho_nu/dT_nu (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), drho_nu_dT_nu)\n", - "\n", - " #print(\"C_n_nue (for T_g={:.1f}, T_nue={:.1f}, T_numt={:.1f}, mu_nue={:.1f}, mu_numt={:.1f})=\".format(T_g, T_nue, T_numt, mu_nue, mu_numt), C_n_nue)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "871be4bf", - "metadata": {}, - "outputs": [], - "source": [ - "#thermo quantities (neutrino temp, photon energy density) versus photon temperature. choose nonzero mus\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "511383cf", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Finished constructing interpolation functions. \n", - " solve system from T_ini = 10.000 to T_fin = 0.009 [MeV]\n", - " --> t_ini = 7.39E-03 [s] to t_fin = 1.63E+04 [s]\n", - "\n", - "Progress: 100.000 %" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import sys\n", - "sys.path.append(r\"C:\\Users\\grace\\nudec_BSM\\BasicModules_source\")\n", - "import nudec_v2\n", - "nudec = nudec_v2.NuDec()\n", - "\n", - "import time\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from importlib import reload\n", - "\n", - "#import BasicModules_source.nudec_v2\n", - "\n", - "#nudec_source = reload(BasicModules_source.nudec_v2)\n", - "\n", - "\n", - "T_g = thermo.T_g(rho_g_vec)\n", - "plt.loglog(T_g, rho_g_vec, label=r\"$\\rho_\\gamma$\")\n", - "\n", - "\n", - "plt.title(\"T_g vs. rho_g\")\n", - "plt.xlabel(\"T_g (MeV)\")\n", - "plt.ylabel(\"rho_g (MeV^4)\")\n", - "\n", - "t_nudec, y_nudec = nudec.evolve()\n", - "\n", - "T_g_nudec = y_nudec[0]\n", - "\n", - "rho_g_nudec = (np.pi**2 / 15) * T_g_nudec**4\n", - "\n", - "plt.loglog(T_g_nudec, rho_g_nudec, label=\"NuDec\")" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "4d42b814", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Finished constructing interpolation functions. rho_nue_std= [Array(0.02538031, dtype=float64, weak_type=True), Array(0.03154887, dtype=float64, weak_type=True), Array(0.04960956, dtype=float64, weak_type=True), Array(0.08379177, dtype=float64, weak_type=True), Array(0.140427, dtype=float64, weak_type=True), Array(0.22753964, dtype=float64, weak_type=True), Array(0.35466176, dtype=float64, weak_type=True), Array(0.53276147, dtype=float64, weak_type=True), Array(0.77421426, dtype=float64, weak_type=True), Array(1.09279044, dtype=float64, weak_type=True)]\n", - "rho_nue_nudec= [np.float64(0.025380307425122914), np.float64(0.03154887023860299), np.float64(0.049609552386488426), np.float64(0.0837917410801468), np.float64(0.1404269050871636), np.float64(0.22753941648258197), np.float64(0.3546612930175843), np.float64(0.5327606213566303), np.float64(0.7742128242095982), np.float64(1.0927881535123134)]\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'rho_nue vs. T_nue for mu_nue=1')" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import sys\n", - "sys.path.append(r\"C:\\Users\\grace\\nudec_BSM\\BasicModules_source\")\n", - "import nudec_v2\n", - "nudec = nudec_v2.NuDec()\n", - "\n", - "import time\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from importlib import reload\n", - "\n", - "mu=1\n", - "\n", - "T_nue = np.arange(0.01, 1, 0.1)\n", - "rho_nue_std = []\n", - "rho_nue_nudec = []\n", - "for T in T_nue:\n", - " rho_nue_linx = thermo.rho_nue_std(T, mu)\n", - " rho_nue_nudecbsm = nudec.thermo.Rho_FD(T, mu)\n", - " rho_nue_std.append(rho_nue_linx)\n", - " rho_nue_nudec.append(rho_nue_nudecbsm)\n", - "print(\"rho_nue_std=\", rho_nue_std)\n", - "print(\"rho_nue_nudec=\", rho_nue_nudec)\n", - "\n", - "plt.loglog(T_nue, rho_nue_std, label=\"rho_nue_std\")\n", - "plt.loglog(T_nue, rho_nue_nudec, label=\"rho_nue_nudec\")\n", - "\n", - "plt.xlabel(\"T_nue (MeV)\")\n", - "plt.ylabel(\"rho_nue (MeV^4)\")\n", - "plt.title(\"rho_nue vs. T_nue for mu_nue={}\".format(mu))" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "id": "bea7f67d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "rho_nue_linx= [0.02538031 0.03154887 0.04960956 0.08379177 0.140427 0.22753964\n", - " 0.35466176 0.53276147 0.77421426 1.09279044]\n", - "rho_nue_nudec= [0.02538031 0.03154887 0.04960955 0.08379174 0.14042691 0.22753942\n", - " 0.35466129 0.53276062 0.77421282 1.09278815]\n", - "rho_nue_residuals= [1.31626872e-12 1.55039714e-08 1.30968819e-07 3.68215112e-07\n", - " 6.72266008e-07 9.93299208e-07 1.30425018e-06 1.59349267e-06\n", - " 1.85788175e-06 2.09656629e-06]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHJCAYAAAB+GsZPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVIlJREFUeJzt3XlcVPX+x/HXCAKuKC4Y7mmpiGLikpp7YuSSW3n1umRYWd5bys9Wb6XVjbJS6wqWdZVsNUu9Zotyr5qWmiulUqk3F1TcFZQUFM7vj3OBBhCHETgzzPv5eMwDzvdsnxnmMJ/5bsdmGIaBiIiIiOQoZ3UAIiIiIq5GCZKIiIhIHkqQRERERPJQgiQiIiKShxIkERERkTyUIImIiIjkoQRJREREJA8lSCIiIiJ5KEESERERyUMJkricRo0ace+9915zu7Vr12Kz2Vi7dq1LxFOcDhw4QL9+/QgICMBmszFp0qQiHyMuLg6bzcbWrVuLP0ApUPZ70pGHO/vHP/5B06ZN8fHxwWazce7cOatDkkLMnj2bIUOG0LhxY2w2Gz169LA6JLfgbXUAInktXbqUqlWrWh2GpSZPnswPP/zA/PnzqVOnDjfccIPVIYkD2rZty8aNG+3KBg8eTJMmTXjttdcsiqp4JSQk8MgjjzB+/HjGjh2Lt7c3VapUsTosKcRbb71FpUqV6NWrF1988YXV4bgNJUhyXX7//XcqVqxYrMe85ZZbivV47mjXrl106NCBQYMGFXlfwzC4dOlS8Qcl11S1alVuvfVWuzJfX1+qVauWr9xd7d69G4D777+fDh06FMsxS+L/iORKTEykXDmzwSgkJMTiaNyHmtjEYdOmTcNms7F9+3aGDRtG9erVadKkCWB+KMfGxtKmTRsqVKhA9erVGTZsGL/99pvdMXbs2EH//v2pXbs2vr6+BAUF0a9fPw4fPpyzTUFNWr/88gt33HEHFStWpGbNmkyYMIHz58/ni/FqzWE9evSwq1a+dOkS//d//0ebNm3w9/cnICCATp068a9//euar0NWVhYvvvgizZo1o0KFClSrVo3WrVvzxhtvXHPfQ4cOMWrUqJzn36JFC15//XWysrKA3Caaffv28fXXX+c0xxw4cOCqx7TZbPzlL3/hrbfeokWLFvj6+vLee+/lrD9//jwPPfQQNWvWpEaNGgwZMoSjR4/me04zZsygefPm+Pr6Urt2bcaMGWP3d3FEdrPemjVrrnlOm83GtGnT8h2joL/hsWPHePDBB6lXrx4+Pj40btyY6dOnc+XKlULjGTRoEA0bNsx5ff+oY8eOtG3bNmd58eLFdOzYEX9/fypWrMiNN97Ifffd5/iTLwEHDhzAZrPx2muvMXPmTBo3bkzlypXp1KkTmzZtsts273s827333kujRo3syjIyMnjxxRdz/t61atVi3LhxnDx5stB4evTowahRowDz9bPZbHZ/q/nz5xMaGoqfnx8BAQEMHjyYn3/+OV88lStXZufOnYSHh1OlShV69+591XNm/9/56aefuPvuu3Ou16ioKK5cucKvv/7KHXfcQZUqVWjUqBEzZsyw2z/7PZn3GnKmid7V3t+Oyk6OpGj0qkmRDRkyhKZNm7J48WLeeustAB588EEmTZrE7bffzrJly4iNjWX37t107tyZ48ePA5CWlkafPn04fvw4MTExxMfHM3v2bBo0aFBgspPt+PHjdO/enV27dhEbG8v777/PhQsX+Mtf/uL0c0hPT+fMmTNMmTKFZcuW8fHHH3PbbbcxZMgQFi5cWOi+M2bMYNq0aYwYMYIvv/ySRYsWERkZec1+GCdPnqRz586sWrWKF154geXLl3P77bczZcqUnOeS3URTp04dunTpwsaNG9m4ceM1m9iWLVvG3LlzefbZZ1m5ciVdu3bNWTd+/HjKly/PRx99xIwZM1i7dm3Oh1y2hx56iCeeeII+ffqwfPlyXnjhBb755hs6d+7MqVOnCj13QRw5p6OOHTtGhw4dWLlyJc8++yxff/01kZGRREdHc//99xe673333cehQ4dYvXq1Xfkvv/zC5s2bGTduHAAbN25k+PDh3HjjjXzyySd8+eWXPPvss8X2AXW9/ni9fPjhh6SlpXHnnXeSkpJS5GNlZWVx11138fLLLzNy5Ei+/PJLXn75ZeLj4+nRowcXL1686r6xsbH87W9/A2DBggVs3LiRZ555BoDo6GgiIyNp2bIlS5Ys4Y033uCnn36iU6dO7N271+44GRkZDBw4kF69evGvf/2L6dOnXzPue+65h9DQUD7//HPuv/9+Zs2axeTJkxk0aBD9+vVj6dKl9OrViyeeeIIlS5YU+XUpCqve35mZmVy5cuWaj4K+EIgTDBEHPffccwZgPPvss3blGzduNADj9ddftytPSkoyKlSoYDz++OOGYRjG1q1bDcBYtmxZoedp2LChMXbs2JzlJ554wrDZbEZCQoLddn369DEAY82aNVfdN1v37t2N7t27X/WcV65cMS5fvmxERkYat9xyS6Hx9O/f32jTpk2hz6EgTz75pAEYP/zwg135Qw89ZNhsNuPXX3+1O2e/fv0cOi5g+Pv7G2fOnLErX7BggQEYDz/8sF35jBkzDMBITk42DMMwfv755wK3++GHHwzAePrppx1+jo6eMzvu5557Lt8x8r7eDz74oFG5cmXj4MGDdtu99tprBmDs3r37qvFcvnzZCAwMNEaOHGlX/vjjjxs+Pj7GqVOn7I517tw5R5+qw4ryt8xr//79BmC0atXKuHLlSk755s2bDcD4+OOPc8qu9h4fO3as0bBhw5zljz/+2ACMzz//3G67LVu2GIARGxtbaEzZf+MtW7bklJ09e9aoUKGCceedd9pte+jQIcPX19fu9R87dqwBGPPnzy/0PNmy/+/k/f/Spk0bAzCWLFmSU3b58mWjVq1axpAhQ/LFu3//frv916xZk+//x7VY/f5u2LChAVzzUdB5s7Vs2bLQ/4WSSzVIUmRDhw61W16xYgU2m41Ro0bZfYupU6cOoaGhOVXYTZs2pXr16jzxxBO89dZbJCYmOnS+NWvW0LJlS0JDQ+3KR44ceV3PY/HixXTp0oXKlSvj7e1N+fLl+ec//5mvSSCvDh068OOPP/Lwww+zcuVKUlNTHTrf6tWrCQ4Oztdv495778UwjHy1HEXRq1cvqlevXuC6gQMH2i23bt0agIMHDwLm65sdxx916NCBFi1a8J///KfI8VzrnEWxYsUKevbsSVBQkN37KyIiAoBvv/32qvt6e3szatQolixZklPbkpmZyfvvv89dd91FjRo1AGjfvj1g1lJ8+umnHDlypMhxlqR+/frh5eWVs3y9r2e1atUYMGCA3evZpk0b6tSp49So0I0bN3Lx4sV876H69evTq1evAt9Def+PXEv//v3tllu0aIHNZst5H4D5927atKlTr0tRWPX+/uKLL9iyZcs1Hw888MB1PDvJpgRJiixvc8/x48cxDIPAwEDKly9v99i0aVNOE42/vz/ffvstbdq04emnn6Zly5YEBQXx3HPPcfny5aue7/Tp09SpUydfeUFljlqyZAn33HMPdevW5YMPPmDjxo1s2bKF++6775odnJ966ilee+01Nm3aREREBDVq1KB3797XHE5/+vTpApvKgoKCctY7q7AmuOwkIJuvry9ATlNK9nmvFpszcV3rnEVx/Phxvvjii3zvrZYtWwJcswkw+2/6ySefALBy5UqSk5NzmtcAunXrxrJly7hy5QpjxoyhXr16hISE8PHHHxc53pJQ3K/nuXPn8PHxyfeaHjt2zKkm1aK+hypWrFjkkaoBAQF2yz4+PlSsWBE/P7985SU9SMGq93dwcDBt2rS55uN6/jdKLo1ikyLLO4dLzZo1sdlsrF+/PucfxR/9saxVq1Z88sknGIbBTz/9RFxcHM8//zwVKlTgySefLPB8NWrU4NixY/nKCyrz8/MjPT09X/mpU6eoWbNmzvIHH3xA48aNWbRokd3zKWjfvLy9vYmKiiIqKopz587x73//m6effpq+ffuSlJR01dE4NWrUIDk5OV95dufOP8ZXVNczr072P/vk5GTq1auXL7briaswvr6+Bb7eeT9Ma9asSevWrfn73/9e4HGyE8yrya61W7BgAQ8++CALFiwgKCiI8PBwu+3uuusu7rrrLtLT09m0aRPR0dGMHDmSRo0a0alTpyI+u9Ln5+dXYJ+kvAlPdsfib775psDjODNk/4/vobwKeg+V5jxQ2QlU3veaM4lgUZTE+7tJkyYO1VI999xzBXYQl6JRgiTXrX///rz88sscOXKEe+65x6F9bDYboaGhzJo1i7i4OLZv337VbXv27MmMGTP48ccf7ZrZPvroo3zbNmrUiJ9++smubM+ePfz66692/6RtNlvOJHfZjh075tAotj+qVq0aw4YN48iRI0yaNIkDBw4QHBxc4La9e/cmOjqa7du3242eWrhwITabjZ49exbp3MWlV69egJk0Zjc1AWzZsoWff/6ZqVOnlsh5C/pbrV69mgsXLtiV9e/fn6+++oomTZpctRnxWsaNG8dDDz3Ed999xxdffEFUVJRdk9Uf+fr60r17d6pVq8bKlSvZsWOHWyRIjRo1YvHixaSnp+d8KTl9+jQbNmywq63p378/n3zyCZmZmXTs2LFYzt2pUycqVKjABx98wN13351TfvjwYVavXs2wYcOK5TzOyB7B99NPP9GsWbOc8uXLl5f4eYv7/f3FF1849CXuWl8axDFKkOS6denShQceeIBx48axdetWunXrRqVKlUhOTua7776jVatWPPTQQ6xYsYLY2FgGDRrEjTfeiGEYLFmyhHPnztGnT5+rHn/SpEnMnz+ffv368eKLLxIYGMiHH37IL7/8km/b0aNHM2rUKB5++GGGDh3KwYMHmTFjBrVq1bLbrn///ixZsoSHH36YYcOGkZSUxAsvvMANN9yQb8RNXgMGDCAkJIR27dpRq1YtDh48yOzZs2nYsCE33XTTVfebPHkyCxcupF+/fjz//PM0bNiQL7/8ktjYWB566CFuvvnma7zSJaNZs2Y88MAD/OMf/6BcuXJERERw4MABnnnmGerXr8/kyZNL5LyjR4/mmWee4dlnn6V79+4kJiYyZ84c/P397bZ7/vnniY+Pp3PnzjzyyCM0a9aMS5cuceDAAb766iveeuutfDVfeY0YMYKoqChGjBhBenp6vr4yzz77LIcPH6Z3797Uq1ePc+fO8cYbb1C+fHm6d++es523tzfdu3d3ql9WSRs9ejRvv/02o0aN4v777+f06dPMmDEjX1PWn/70Jz788EPuvPNOHn30UTp06ED58uU5fPgwa9as4a677mLw4MFFOne1atV45plnePrppxkzZgwjRozg9OnTTJ8+HT8/P5577rnifKpF0r59e5o1a8aUKVO4cuUK1atXZ+nSpXz33Xclet6SeH+3atXKqVi2bt2aM81BamoqhmHw2WefAebr07BhQ+efaFlmaRdxcSvZo0lOnjxZ4Pr58+cbHTt2NCpVqmRUqFDBaNKkiTFmzBhj69athmEYxi+//GKMGDHCaNKkiVGhQgXD39/f6NChgxEXF2d3nIJGoiUmJhp9+vQx/Pz8jICAACMyMtL417/+lW8USlZWljFjxgzjxhtvNPz8/Ix27doZq1evLnCEz8svv2w0atTI8PX1NVq0aGG88847Oc+xsHhef/11o3PnzkbNmjUNHx8fo0GDBkZkZKRx4MCBa76GBw8eNEaOHGnUqFHDKF++vNGsWTPj1VdfNTIzM/Odsyij2CZOnJivvKDRRoZR8OidzMxM45VXXjFuvvlmo3z58kbNmjWNUaNGGUlJSQ7F4Mw509PTjccff9yoX7++UaFCBaN79+5GQkJCgX//kydPGo888ojRuHFjo3z58kZAQIARFhZmTJ061bhw4YJDsY0cOdIAjC5duuRbt2LFCiMiIsKoW7eu4ePjY9SuXdu48847jfXr19ttBxR5BFBxjGJ79dVX862jgNFK7733ntGiRQvDz8/PCA4ONhYtWpRvFJthmKO9XnvtNSM0NNTw8/MzKleubDRv3tx48MEHjb179xYa09X+xoZhGO+++67RunVrw8fHx/D39zfuuuuufKMMx44da1SqVMmxF8C4+v+dqx2ne/fuRsuWLe3K9uzZY4SHhxtVq1Y1atWqZfz1r381vvzyS6dHsbni+7sw2SMHC3osWLDguo9fVtkMwzBKMR8TERERcXkaxSYiIiKSh/ogicg1GYZBZmZmodt4eXm5/V3qS9O1ZukuV66cbhFRSvT+loLo6hORa3rvvffyzdOS91HYhI1i78CBA9d8PZ9//nmrw/QYen9LQdQHSUSu6fTp0+zfv7/QbZo1a+bUHDqeKCMjI98Q8LyCgoI0XLuU6P0tBVGCJCIiIpKH+iA5KSsri6NHj1KlShW1S4uIiLgJwzA4f/48QUFBhfbzU4LkpKNHj1K/fn2rwxAREREnJCUlFTrJrBIkJ2W3RSclJRX5posiIiJijdTUVOrXr3/NPmVKkIooJiaGmJiYnCGhVatWVYIkIiLiZq7VPUadtJ2UmpqKv78/KSkpSpBERETchKOf35oHSURERCQPJUgiIiIieShBEhEREclDCZKIiIhIHkqQRERERPJQglREMTExBAcH0759e6tDERERkRKiYf5O0jB/ERER96Nh/iIiIiJOUoIkIiIikocSJBEREZE8lCCJiIiI5KEESURERCQPJUgiIiLiUg4fhh07rI1BCZKIiIhYZuVKGDAAXnwxtywoCH780bqYQAlSkWmiSBEREeds2AB//zscP55bduIErFhhPrKVKwcREaUf3x9pokgnaaJIERGRqzMMOHYMbrght6xtW7Pp7OOP4U9/MsuOHoVPPoEePcz1Jc3Rz2/vkg9FREREPMnPP8Ptt5u/Hz4MNpv5++DB0KQJ1KmTu21QEERFlX6M16IESURERJz244+waBG0agUjRphljRvD2bNmLdKhQ9CwoVn+zDPWxVlU6oMkIiIiDtu/Hy5fzl1evRqio+G993LL/Pzgu+/MJCk7OXI3SpBERETEIeHhcOONsG5dbtmdd8KoUTBunP22bduaiZK7UoIkIiIidi5fhv/8B2bMsC9v0MAcYbZzZ25Zs2bw/vswfHjpxljSNIrNSRrFJiIiZYlh5HamPn7cHH1mGJCUBPXqmeVJSVChAtSsaV2c10uj2EREROSaNm40J2kMCoJ33jHLAgNh4ECoUcO+v1H9+tbEaAUlSCIiIh4kORl8fSEgwFy+cgW++gqqV4e5c8H7f5nBsmWWhegS1AdJRETEQzzxhNlcll1TBNC5s9nX6LvvwMvLuthcjUcnSPv376dnz54EBwfTqlUr0tLSrA5JRESkWFy+DF9+CZcu5ZbddBNkZZkTOWbz8oLHHoPg4Nw+SOLhTWz33nsvL774Il27duXMmTP4+vpaHZKIiEix6NjRvK3H55/DkCFm2fDh0LOnOZu1FM5ja5B2795N+fLl6dq1KwABAQF4e3t0vigiIm5q716YM8e+7PbboXZtSEnJLatSRcmRo1w2QVq3bh0DBgwgKCgIm83GsgJ6i8XGxtK4cWP8/PwICwtj/fr1Dh9/7969VK5cmYEDB9K2bVteeumlYoxeRESkdKSmQkgI/PWvsGtXbvnf/gZHjuSfwFEc47JVJmlpaYSGhjJu3DiGDh2ab/2iRYuYNGkSsbGxdOnShbfffpuIiAgSExNp0KABAGFhYaSnp+fbd9WqVVy+fJn169eTkJBA7dq1ueOOO2jfvj19+vQp8ecmIiLijIsXYckScz6iJ580y6pWhQEDIC0NMjJyt9UUfdfHLSaKtNlsLF26lEGDBuWUdezYkbZt2zJ37tycshYtWjBo0CCio6OvecyNGzcyffp0vvnmGwBeffVVAB577LECt09PT7dLtlJTU6lfv74mihQRkVKzaRN06mQO0z9+HPz9zfKsLHOGa7k2RyeKdMuXMyMjg23bthEeHm5XHh4ezoYNGxw6Rvv27Tl+/Dhnz54lKyuLdevW0aJFi6tuHx0djb+/f86jvifNliUiIqUuKwtWrTI7WWfr2BEGDzZrjzIzc8uVHBU/l21iK8ypU6fIzMwkMDDQrjwwMJBjx445dAxvb29eeuklunXrhmEYhIeH079//6tu/9RTTxEVFZWznF2DJCIiUhI++8wcdVa/Ptx1lzmBo81mNrFJyXPLBCmbLc+EDYZh5CsrTEREBBEREQ5t6+vri6+vLzExMcTExJD5x9RdRETkOu3aBenpEBZmLg8cCDfeCP36we+/q09RaXPLSrmaNWvi5eWVr7boxIkT+WqVitvEiRNJTExky5YtJXoeERHxHPPmQatWMGVKbpmfH+zZA2++qeTICm6ZIPn4+BAWFkZ8fLxdeXx8PJ07d7YoKhEREcccP24Owc8WEWF2vK5Rw34kmm79YR2XbWK7cOEC+/bty1nev38/CQkJBAQE0KBBA6Kiohg9ejTt2rWjU6dOzJs3j0OHDjFhwoQSjUtNbCIicj3mzIGoKLjvPnjrLbOsfn04ejT3BrJiPZcd5r927Vp69uyZr3zs2LHExcUB5kSRM2bMIDk5mZCQEGbNmkW3bt1KJT5HhwmKiIhnu3jRHJFWqZK5vG4ddO8OvXtDfLzuf1baHP38dtkEydUpQRIRkWuJiYFnn4Wnn4b/+z+zzDBg505o3dra2DxVmZ4HyUoxMTEEBwfTvn17q0MREREX5+MDZ87Al1/mltlsSo7cgWqQnKQaJBER+aPffoMXX4RRo6BXL7MsLQ3+8x9zqL46XLsGRz+/XbaTtoiIiDt54w1YsMAcmp+dIFWqZM5nJO5HCZKIiIgTkpKgfHmoU8dcfvJJ2L8fpk61Ni4pHuqDVETqgyQiIrGx0LQpTJuWW3bDDbB8uXm/NHF/SpCKSDNpi4hISIg5oeNvv5lD+KXsUYIkIiJSiOPHzSH6776bW9atG2zdCqtWQTl9kpZJ6oMkIiJSiM8/h5kzISjIHKHm52eWZ99UVsom5b1FpD5IIiJl25kz8Ic7XREZCYMGwT//ad4vTTyD5kFykuZBEhEpe1asgJEjzdqhNWusjkZKgmbSFhERKaLQUEhPh7NnzYd4LvVBEhERj3T+PLz5Jly6BC+8YJbVrw+bN0OrVup87emUIImIiEfasgX+9jfzfmkTJkDdumZ5aKi1cYlrUH5cROqkLSLintLS4Mcfc5d79jQ7YMfF5c6GLZJNnbSdpE7aIiLuY+tW6N/fHIW2Z49Go3kyddIWERH5n+bNzaY0b2/zfmki16IESUREypyMDFi6NHe5cmWIj4effzaTJZFrUYIkIiJlSnq6OY/RkCHmrUCyNWtm1iKJOEIJkoiIlCm+vtC7N9SubSZLIs5QgiQiIm7NMODDD+HEidyyF180m9MGDLAuLnFvSpCKSMP8RURcy6RJ5k1k/+//cssqV4aAAMtCkjJACVIRTZw4kcTERLZs2WJ1KCIigpkcVaoEwcFmbZJIcdBM2iIi4lbWrYMzZ2DQIHO5fXtISoLq1S0NS8oYJUgiIuI2vvkGIiKgRg247TaoWdMsV3IkxU0JkoiIuI3evaFNG+jQwZz0UaSk6O0lIiIua+9e+Oc/IToabDYoXx42bgQ/P6sjk7JOCZKIiLikCxegY0c4e9bsgD1mjFmu5EhKgxIkERFxSZUrw+OPw5o10KWL1dGIp9EwfxERcQmnT8ODD8K+fblljz1mdsxu0sS6uMQzKUEqIk0UKSJSMiZOhHnz4OGHc8u8vMy+RyKlzWYYmlbLGampqfj7+5OSkkLVqlWtDkdExO3t2wcjRsAbb0DnzlZHI2WVo5/f6oMkIiKlLj0dZswwZ8COijLLmjaFzZtVYySuQQmSiIiUui++gGefNUekDR8Odeua5UqOxFUoQRIRkVI3dCiMHAkDBkBQkNXRiOSnTtoiIlKiDAMWLoTbb4fLl80ymw0+/BD+9CfVGolrUoIkIiIl6tw5s5/Rf/4DCxZYHY2IY9TEJiIixS4rC8r97yt49ermyLSkJBg3ztq4RBylGiQRESlW334LrVqZI9Ky/fnP8OST5r3URNyBEiQRESlW//wnJCbCM89YHYmI89TEJiIixer116FGDXjuOasjEXGeapBEROS6LF4ML72Uu1yrFsyaBdWqWRaSyHXz2ATp119/pU2bNjmPChUqsGzZMqvDEhFxKzt2wD33wNSpsH691dGIFB+PbWJr1qwZCQkJAFy4cIFGjRrRp08fa4MSEXEzt9wCf/0rVKwInTpZHY1I8fHYBOmPli9fTu/evalUqZLVoYiIuLxNm6B1azMpAnMIvyZ7lLLGZZvY1q1bx4ABAwgKCsJmsxXY/BUbG0vjxo3x8/MjLCyM9U7W73766acMHz78OiMWESn75s2D226Dhx4yZ8gGJUdSNrlsDVJaWhqhoaGMGzeOoUOH5lu/aNEiJk2aRGxsLF26dOHtt98mIiKCxMREGjRoAEBYWBjp6en59l21ahVB/7v5T2pqKt9//z2ffPJJofGkp6fbHSs1NfV6np6IiFu6+WbzZ2YmXLmieY2k7LIZRvZ3ANdls9lYunQpgwYNyinr2LEjbdu2Ze7cuTllLVq0YNCgQURHRzt87Pfff5+VK1fywQcfFLrdtGnTmD59er7ylJQUqlat6vD5RETczZUr4P2Hr9MJCRAaqpojcU+pqan4+/tf8/PbZZvYCpORkcG2bdsIDw+3Kw8PD2fDhg1FOpajzWtPPfUUKSkpOY+kpKQinUdExB198ok5K/bJk7llbdooOZKyzy0TpFOnTpGZmUlgYKBdeWBgIMeOHXP4OCkpKWzevJm+fftec1tfX1+qVq3K+++/z6233krv3r2LHLeIiDtJT4dp0+CXX8x5jUQ8iVsmSNlseb7CGIaRr6ww/v7+HD9+HB8fH4f3mThxIomJiWzZssXhfURE3JGvLyxZYt4y5IUXrI5GpHS5ZYJUs2ZNvLy88tUWnThxIl+tkoiIOG7NGlixInc5OBiefx68vKyLScQKbpkg+fj4EBYWRnx8vF15fHw8nTt3LtFzx8TEEBwcTPv27Uv0PCIipW31arj9dvjzn2HfPqujEbGWyw7zv3DhAvv+cIXu37+fhIQEAgICaNCgAVFRUYwePZp27drRqVMn5s2bx6FDh5gwYUKJxjVx4kQmTpyY0wteRKSs6NoVOneGG2+E/82EIuKxXDZB2rp1Kz179sxZjoqKAmDs2LHExcUxfPhwTp8+zfPPP09ycjIhISF89dVXNGzY0KqQRUTczsGD0KCBOSqtfHn45htzhmyNUhNP5xbzILmSmJgYYmJiyMzMZM+ePZoHSUTc1scfw/jx8Mor8Je/WB2NSOko0/MgWUmj2ESkrDh2DH7/3aw10ldlEXsu28QmIiIla9IkuOEGuPtuNamJ5KUaJBERD7F6tZkMXbliLtts8Kc/aQi/SEGUIBWRhvmLiDtKSYGhQ+Gzz+DNN62ORsT1qZO2kxzt5CUi4io+/9ycBDI2FipUsDoaEWs4+vmtPkgiImXUTz+Bjw80b24uDx1qPkTk2tTEJiJSBq1cCbfeCkOGwIULVkcj4n6UIBWR+iCJiDto0waqVzcngczIsDoaEfejPkhOUh8kEXE1Fy/a9y06cADq19coNZE/0kSRIiIe5N//Nu+htm5dblmjRkqORJylBElEpAxYuNCcGfuVV6yORKRs0Cg2EZEyYO5cswbpySetjkSkbFANUhGpk7aIuIKEBPvaokqVYNo08POzKiKRskWdtJ2kTtoiYpWjR6FpU7NT9uefm0P5RcQxmihSRKSMCgqCRx+FH3+EHj2sjkakbFKCJCLiBg4dgmrVIPsL74svmjebLaeOEiIlQpeWiIiLW70abrkFxo2D7E4RXl5KjkRKki4vEREXV6kSnD9v1iKlpFgdjYhnUBObiIgLMgyzCQ2gY0dYtcq8t5pGqYmUDtUgFZGG+YtISdu+HTp3hiNHcst69FByJFKaNMzfSRrmLyIlwTDM5GjTJhgxAj76yOqIRMoW3YtNRMQN2WzwwQcwciTExFgdjYjnUoIkImKxAwfgyy9zl5s0gQ8/hOrVLQtJxOOpk7aIiIV+/dVsUrt4EX74AVq1sjoiEQElSCIilmraFNq1g7Nnwd/f6mhEJJsSJBGRUpaSAlWqmBM9ennBokVQoQL4+lodmYhkUx8kEZFStG0bhIbCK6/kllWrpuRIxNUoQRIRKUUJCXDwIMTFwaVLVkcjIlejJjYRkVIUGQnp6eYwfk38KOK6VINURJpJW0SKYv9+GD/eTIqyPfyw2awmIq5LM2k7STNpi8i1XLkCzZvDf/8LU6bAq69aHZGIaCZtERGLeXvDP/5hznP0yCNWRyMiRaEESUSkGJ06Bb/8krscEQHr10P9+tbFJCJFpwRJRKSY7N4NYWHQr5858WO2cvpPK+J2dNmKiBSTG24wk6Fy5cyaJBFxXxrmLyJSTAIC4JtvoE4d3TZExN2pBklE5DrExsLatbnLzZopORIpC1SDJCLipE8/hYkTzfuq7dwJDRtaHZGIFBclSCIiTho4EHr0MB8NGlgdjYgUJyVIIiJFkJWVOyrNzw9WrYLy5a2NSUSKn0f3QZo1axYtW7YkODiYRx55BE0qLiKFSUszh/DPm5dbpuRIpGzy2ATp5MmTzJkzh23btrFz5062bdvGpk2brA5LRFzYBx+Yo9SmTIGTJ62ORkRKkkc3sV25coVLly4BcPnyZWrXrm1xRCLiyh54APbtgyFDoFYtq6MRkZLksjVI69atY8CAAQQFBWGz2Vi2bFm+bWJjY2ncuDF+fn6EhYWxfv16h49fq1YtpkyZQoMGDQgKCuL222+nSZMmxfgMRKQsOHzY7HcEYLOZN5zt1MnamESk5LlsgpSWlkZoaChz5swpcP2iRYuYNGkSU6dOZceOHXTt2pWIiAgOHTqUs01YWBghISH5HkePHuXs2bOsWLGCAwcOcOTIETZs2MC6deuuGk96ejqpqal2DxEp27Zvh7Zt4dFHQV0URTyLyzaxRUREEBERcdX1M2fOJDIykvHjxwMwe/ZsVq5cydy5c4mOjgZg27ZtV91/8eLFNG3alICAAAD69evHpk2b6NatW4HbR0dHM336dGefjoi4ob17zVuGfP89XLhgznckIp7BZWuQCpORkcG2bdsIDw+3Kw8PD2fDhg0OHaN+/fps2LCBS5cukZmZydq1a2nWrNlVt3/qqadISUnJeSQlJV3XcxAR1zd8OHz2mTlTtpIjEc/ilgnSqVOnyMzMJDAw0K48MDCQY8eOOXSMW2+9lTvvvJNbbrmF1q1b06RJEwYOHHjV7X19falatSrvv/8+t956K717976u5yAirmnpUrO2KNuQIVC1qnXxiIg13DJBymaz2eyWDcPIV1aYv//97/z888/s3r2bN99806F9J06cSGJiIlu2bClyvCLi2ubMMROiIUMgI8PqaETESm6ZINWsWRMvL698tUUnTpzIV6skIuKoDh2gUiW45RZNACni6dwyQfLx8SEsLIz4+Hi78vj4eDp37lyi546JiSE4OJj27duX6HlEpPR16AC7d8Mrr5hD+kXEc7lsgnThwgUSEhJISEgAYP/+/SQkJOQM44+KiuLdd99l/vz5/Pzzz0yePJlDhw4xYcKEEo1LTWwiZcelSzBhAhw8mFvWsKF18YiI63DZYf5bt26lZ8+eOctRUVEAjB07lri4OIYPH87p06d5/vnnSU5OJiQkhK+++oqG+u8mIg569FHzvmobN5pzHnl5WR2RiLgKm6E7tBZJTEwMMTExZGZmsmfPHlJSUqiqIS4ibunwYbjzTnjzTejRw+poRKQ0pKam4u/vf83PbyVITnL0BRYR13LlCnj/oe48KwvKuWxnAxEpbo5+fuvfgoh4jN27ITjYnBk7m5IjESmI/jWIiMeIjjZvH/Lkk7q3mogUzmU7abuqP/ZBEhH3Mm8eVK8O06drGL+IFE59kJykPkgi7mHPHrj5ZqujEBFXoT5IIuLxYmKgRQt47z2rIxERd+NUgpSUlMThw4dzljdv3sykSZOYN29esQUmInK99u83R6lt3251JCLibpxKkEaOHMmaNWsAOHbsGH369GHz5s08/fTTPP/888UaoKvRrUZE3Merr8LSpTB7ttWRiIi7cSpB2rVrFx06dADg008/JSQkhA0bNvDRRx8RFxdXnPG5HN1qRMR1ZWTAO+/kjlCz2WDQIHXIFpGicypBunz5Mr6+vgD8+9//ZuDAgQA0b96c5OTk4otORMRBhgFDh8IDD8BTT1kdjYi4O6cSpJYtW/LWW2+xfv164uPjueOOOwA4evQoNWrUKNYARUQcYbPBsGFQqZJuGyIi18+pBOmVV17h7bffpkePHowYMYLQ0FAAli9fntP0JiJS2saOhX374H/f2UREnOb0PEiZmZmkpqZSvXr1nLIDBw5QsWJFateuXWwBuirNgyRivb17Ydo0s99RxYpWRyMi7sDRz2+nZ9L28vKyS44AGjVq5Ozh3IZm0hZxDZmZMGAA/Por+PtDbKzVEYlIWeJwDdItt9yCzcGhINs9YNIR1SCJWO/77+GJJ+DzzyEw0OpoRMQdFHsN0qBBg4ojLhGR63LpEvj5mb936QLr12sYv4gUP92LzUmqQRIpfQsWwIsvwrp1ULeu1dGIiDvSvdhEpExJT4dXXoHffjM7ZYuIlCSnOmlnZmYya9YsPv30Uw4dOkRGRobd+jNnzhRLcCIi2Xx9YeVKeP99mDrV6mhEpKxzqgZp+vTpzJw5k3vuuYeUlBSioqIYMmQI5cqVY9q0acUcomvRvdhESs+VK7BzZ+5yw4bwt7+pz5GIlDyn+iA1adKEN998k379+lGlShUSEhJyyjZt2sRHH31UErG6FPVBEilZly7ByJGwahWsXg2ag1ZEikOJ9kE6duwYrVq1AqBy5cqkpKQA0L9/f7788ktnDikiYsdmg/Pn4fJl0C0eRaS0OZUg1atXL+emtE2bNmXVqlUAbNmyJecmtiIi18PXF5YuhbVr4a67rI5GRDyNUwnS4MGD+c9//gPAo48+yjPPPMNNN93EmDFjuO+++4o1QBHxHAcPmp2ws1WuDJ06WRePiHiuYpkHadOmTWzYsIGmTZsycODA4ojL5akPkkjxOnEC2raFo0dh8WIYOtTqiESkLCrxe7H90a233sqtt95aHIcSEQ9VqxYMHmx2yO7Y0epoRMTTOZUgLVy4sND1Y8aMcSoYEfFcNhu88YbZMdvf3+poRMTTOdXEVr16dbvly5cv8/vvv+Pj40PFihU9YqJINbGJXL9Fi+C77+DNNzW3kYiUjhJtYjt79my+sr179/LQQw/x2GOPOXNIEfEw+/fDqFHmZJC33QbDh1sdkYhIrmLpgwRw00038fLLLzNq1Ch++eWX4jqsy4mJiSEmJobMzEyrQxFxa40bQ0wM/PgjDBtmdTQiIvaKZRRbth07dtC9e3dSU1OL65AuS01sIkWXlQUXL0KlSlZHIiKeqkSb2JYvX263bBgGycnJzJkzhy5dujhzSBEp4zIyYNw4cxj/11+Dn5/VEYmIXJ1TCdKgQYPslm02G7Vq1aJXr168/vrrxRGXiJQxv/0GX3xh1iBt2gQ9elgdkYjI1TmVIGVlZRV3HCJSxjVvDsuXw++/KzkSEddXbJ20RUTyOnoULl2CG280l5UYiYi7cDhBioqKcvigM2fOdCoYESk79u2DPn2gXDn4/nuoU8fqiEREHOdwgrRjxw675W3btpGZmUmzZs0A2LNnD15eXoSFhRVvhCLilipVMid/LFfOrEUSEXEnDidIa9asyfl95syZVKlShffeey9nVu2zZ88ybtw4unbtWvxRiojbueEG+Pe/zUQpMNDqaEREisapeZDq1q3LqlWraNmypV35rl27CA8P5+jRo8UWoKvSPEgi+S1fbt5HrXt3qyMRESmYo5/f5Zw9+PHjx/OVnzhxgvPnzztzSBFxc//+NwwZAgMHwp49VkcjInJ9nEqQBg8ezLhx4/jss884fPgwhw8f5rPPPiMyMpIhQ4YUd4wl5rXXXqNly5aEhITwwQcfWB2OiFvr0sV8DBmSO2pNRMRdOTXM/6233mLKlCmMGjWKy5cvmwfy9iYyMpJXX321WAMsKTt37uSjjz5i27ZtAPTu3Zv+/ftTrVo1awMTcVMVKpgzZFeoYHbOFhFxZ07VIFWsWJHY2FhOnz7Njh072L59O2fOnCE2NpZKbnKTpZ9//pnOnTvj5+eHn58fbdq04ZtvvrE6LBG3ceUKPPAAvPNOblnFikqORKRscCpBylapUiVat25NaGhosSdG69atY8CAAQQFBWGz2Vi2bFm+bWJjY2ncuDF+fn6EhYWxfv16h48fEhLCmjVrOHfuHOfOnWP16tUcOXKkGJ+BSNm2aJGZHE2cCIcOWR2NiEjxcriJbciQIcTFxVG1atVr9jNasmTJdQeWlpZGaGgo48aNY+jQofnWL1q0iEmTJhEbG0uXLl14++23iYiIIDExkQYNGgAQFhZGenp6vn1XrVpFcHAwjzzyCL169cLf35/27dvj7X31lyM9Pd3uWKmpqdf9HEXc2ciRsHEj9OoF/7vkRETKDIcTJH9/f2z/qzv39/cvsYCyRUREEBERcdX1M2fOJDIykvHjxwMwe/ZsVq5cydy5c4mOjgbI6V90NQ8++CAPPvggAOPHj6dp06ZX3TY6Oprp06cX9WmIlCnnzkHVqubkjzYbzJljdUQiIiXDqXmQSpvNZmPp0qUMGjQIgIyMDCpWrMjixYsZPHhwznaPPvooCQkJfPvttw4d98SJE9SuXZtff/2Vu+++m+3bt1+1FqmgGqT69etrHiTxGAcPQng43HEHzJ6tvkYi4p4cnQfJqVFsFy9exDAMKlasCMDBgwdZunQpwcHBhIeHOxdxEZw6dYrMzEwC80zPGxgYyLFjxxw+zqBBgzh37hyVKlViwYIFhTax+fr64uvr63TMIu5u82ZzfqNLl+CZZ6BmTasjEhEpOU4lSHfddRdDhgxhwoQJnDt3jg4dOuDj48OpU6eYOXMmDz30UHHHWSBbnq+whmHkKyvMhg0binzOmJgYYmJiyMzMLPK+Iu7s7rth4ULo2VPJkYiUfU6NYtu+fXvOPdc+++wz6tSpw8GDB1m4cCFvvvlmsQZYkJo1a+Ll5ZWvtujEiRP5apWK28SJE0lMTGTLli0leh4RV/Ddd3DhQu7y6NFQr5518YiIlBanEqTff/+dKlWqAOaIsCFDhlCuXDluvfVWDh48WKwBFsTHx4ewsDDi4+PtyuPj4+ncuXOJnjsmJobg4GDat29foucRsdrnn5sj1IYMgQIGg4qIlGlOJUhNmzZl2bJlJCUlsXLlypx+RydOnCi2DssXLlwgISGBhIQEAPbv309CQgKH/jfhSlRUFO+++y7z58/n559/ZvLkyRw6dIgJEyYUy/mvRjVI4inq1oXy5SEgQB2yRcTzONUH6dlnn2XkyJFMnjyZXr160alTJ8CsTbrllluKJbCtW7fSs2fPnOWoqCgAxo4dS1xcHMOHD+f06dM8//zzJCcnExISwldffUXDhg2L5fwinu7WW+GHH6BFC/DysjoaEZHS5fQw/2PHjpGcnExoaCjlypkVUZs3b6Zq1ao0b968WIN0RY4OExRxF1lZ8PzzMG4c6HuGiJRVjn5+O32rkTp16lClShXi4+O5ePEiAO3bty/zyZH6IElZ9cwzMH26Oc9RRobV0YiIWMupGqTTp09zzz33sGbNGmw2G3v37uXGG28kMjKSatWq8frrr5dErC5FNUhS1iQlQY8eZi3Sn/9sdTQiIiWjRGuQJk+eTPny5Tl06FDOZJEAw4cP55tvvnHmkCJigT9+PapfHxITlRyJiICTCdKqVat45ZVXqJdnQpSbbrqpVIb5W0lNbFJWHD0KnTrBH+dL1WTxIiImpxKktLQ0u5qjbKdOnSrzt+PQMH8pK6ZNM0epPfAAaGJ4ERF7TiVI3bp1Y+HChTnLNpuNrKwsXn31Vbuh+SLiumbNMpvTvvhCw/hFRPJyah6k1157je7du7N161YyMjJ4/PHH2b17N2fOnOH7778v7hhFpJgkJ8MNN5i/V6oEH3xgbTwiIq6qyDVIly9f5uGHH2b58uV06NCBPn36kJaWxpAhQ9ixYwdNmjQpiThdhvogibtavhyaNDFvOCsiIoVzaph/rVq12LBhAzfddFNJxOQWNMxf3M1jj8Frr5n3VvvsM90+REQ8U4kO8x8zZgz//Oc/nQ5ORErfK6/Au+/CokVKjkRErsWpPkgZGRm8++67xMfH065dOypVqmS3fubMmcUSnIg4zzBgyRKzxshmg3LlIDLS6qhERNyDUwnSrl27aNu2LQB79uyxW2fTV1MRl/Dww/DWW2bT2owZVkcjIuJenEqQ1qxZU9xxiEgxa98e3nkHPLiroIiI05xKkDxZTEwMMTExZGpmPXFx990HXbsqQRIRcYZTo9hEo9jE9Zw8ac6O/eqrUMBE9yIiguOf36pBEikDDAMGDDBvHZKWBnFxVkckIuLenBrmLyKuxWYz5zhq3hyeesrqaERE3J9qkETcWGZm7n3UbrsNdu4Eb13VIiLXTTVIIm5q1Spo0waOHs0tU3IkIlI8lCAVke7FJq4gMxOiomDXLnjpJaujEREpezSKzUkaxSZWO3AAXn/dfPj4WB2NiIh7KNF7sYlI6TMM2L8/d7lRI/jHP5QciYiUBCVIIm4gKwsmT4bWrWHrVqujEREp+5QgibiBK1fM/kYXLsD27VZHIyJS9mnMi4gb8PGBpUvh22+hf3+roxERKftUgyTios6ehSVLcperVFFyJCJSWpQgibig1FTo3h2GDYPFi62ORkTE86iJTcQFVakCXbvCqVPm7UNERKR0qQZJxAXZbOYQ/q1boVUrq6MREfE8SpCKSDNpS0lZvx4ef9yc7wigXDkICrI2JhERT6WZtJ2kmbSlOB0/DjfeCL//Du++C5GRVkckIlI2Ofr5rT5IIi4gMNC8ZcjXX8PIkVZHIyIiqkFykmqQpDhkZNjfKsQwzP5HIiJSMnQvNhEXZhjw9NMQEQGXLuWWKzkSEXENSpBELHDwIMyZA6tXm81qIiLiWtQHScQCjRrBv/4F//0vDB5sdTQiIpKXEiSRUnL+vHn7kAYNzOWePc2HiIi4HjWxiZSCU6egVy/o3dsc0i8iIq5NCZJIKcjIMJOkc+cgOdnqaERE5FrUxCZSCoKCID4erlzRvdVERNyBR9QgDR48mOrVqzNs2LB861asWEGzZs246aabePfddy2ITsqqzZvN24dka9pUyZGIiLvwiATpkUceYeHChfnKr1y5QlRUFKtXr2b79u288sornDlzxoIIpazZutXsc9S/P+zebXU0IiJSVB6RIPXs2ZMqVarkK9+8eTMtW7akbt26VKlShTvvvJOVK1daEKGUNS1bQtu20LEjNGxodTQiIlJUlidI69atY8CAAQQFBWGz2Vi2bFm+bWJjY2ncuDF+fn6EhYWx/o/tFtfh6NGj1K1bN2e5Xr16HDlypFiOLZ6tQgVYsQK++AIqV7Y6GhERKSrLO2mnpaURGhrKuHHjGDp0aL71ixYtYtKkScTGxtKlSxfefvttIiIiSExMpMH/JpQJCwsjPT09376rVq0iKCjoqucu6DZ0tqvc6yE9Pd3uHKmpqdd8buI5DANeegnq1IHISLNMt+gTEXFflidIERERREREXHX9zJkziYyMZPz48QDMnj2blStXMnfuXKKjowHYtm2bU+euW7euXY3R4cOH6dixY4HbRkdHM336dKfOI2XfihXwt79BuXLQuTO0aGF1RCIicj0sb2IrTEZGBtu2bSM8PNyuPDw8nA0bNlz38Tt06MCuXbs4cuQI58+f56uvvqJv374FbvvUU0+RkpKS80hKSrru80vZ0b8/3H8/zJyp5EhEpCywvAapMKdOnSIzM5PAwEC78sDAQI4dO+bwcfr27cv27dtJS0ujXr16LF26lPbt2+Pt7c3rr79Oz549ycrK4vHHH6dGjRoFHsPX1xdfX9/rej5Stly6BD4+Zq2RzQZvv23+FBER9+fSCVK2vP2CDMO4al+hghQ2Mm3gwIEMHDjQ4WPFxMQQExNDZmamw/tI2XPunFlr1L69WWtksyk5EhEpS1y6ia1mzZp4eXnlqy06ceJEvlql0jJx4kQSExPZsmWLJecX17B2LXz/PcTFweHDVkcjIiLFzaUTJB8fH8LCwoiPj7crj4+Pp3PnzhZFJQKDBsG8efDtt1C/vtXRiIhIcbO8ie3ChQvs27cvZ3n//v0kJCQQEBBAgwYNiIqKYvTo0bRr145OnToxb948Dh06xIQJEyyJV01snisx0Zz0sVIlc/n++62NR0RESo7NKGgyoFK0du1aevbsma987NixxMXFAeZEkTNmzCA5OZmQkBBmzZpFt27dSjlSe6mpqfj7+5OSkkJVTXhT5n33ndnnqFMn+Ne/zM7ZIiLifhz9/LY8QXJXSpA8y8aNcPvtEBZmznmkP7mIiHty9PPb8iY2d6MmNs/UqROsWQOtWpm3ERERkbJNNUhOUg1S2TdvHkREqBO2iEhZ4ujnt0uPYhOxyptvwoMPQng4XLhgdTQiIlLalCAVUUxMDMHBwbRv397qUKQEDRpk1hyNHZs7ak1ERDyHmticpCa2si81VZ2xRUTKGjWxiRTB+fNmrdHGjbllSo5ERDyXRrGJANOmmfMb7dgBe/dqniMREU+nGiQR4PnnYcAA+PxzJUciIqIapCLTPEhlR0oK+Pubv1eqBMuXWxuPiIi4DtUgFdHEiRNJTExky5YtVoci12HzZrjpJvjgA6sjERERV6QESTzSkiVw8iTMnQtZWVZHIyIirkZNbOKRXnoJatY0J4Msp68JIiKShz4axGN8+y1kz/pVrhxMmQJVqlgbk4iIuCYlSEWkmbTd08svQ48e8PTTVkciIiLuQAlSEamTtnuqVcv86eWVW4skIiJyNeqDJB4hMhLatIGwMKsjERERd6AaJCmTfv8dnnkGLl7MLVNyJCIijlINkpRJw4fDihXmbUM++cTqaERExN2oBknKpMcegzp14C9/sToSERFxR6pBkjLDMMBmM3/v1g1++w0qVLA2JhERcU+qQSoiDfN3TT/9BLfdBkeP5pYpORIREWfZDEODnp2RmpqKv78/KSkpVK1a1epwPJphQIcOsHUrjBgBH31kdUQiIuKqHP38Vg2SuD2bDT79FO6+G2JjrY5GRETKAiVI4rZOnsz9vXFjM0mqVs2ycEREpAxRgiRuafZsaNoUtm2zOhIRESmLlCCJ27lyBZYvh9RU+OILq6MREZGySMP8xe14e8OyZbB4Mdx3n9XRiIhIWaQaJHEL6emwalXuctWq5v3Vsuc9EhERKU5KkMTlXboE/fvDHXeYHbFFRERKmhKkItJEkaXP19fskF2xIgQEWB2NiIh4Ak0U6SRNFFm6MjNh3z5o1szqSERExJ1pokhxaz//DNOmmbNkA3h5KTkSEZHSo1Fs4nJSUqBHDzhxAmrUgL/+1eqIRETE06gGSVyOvz889xy0b2/eW01ERKS0KUESl5GVlfv7ww/D999DzZrWxSMiIp5LCZK4hHnzICLCnO8oW/ny1sUjIiKeTQmSWO74cfi//zMngnz/faujERERUSdtcQGBgeatQ7791pwdW0RExGpKkMQSly/DqVNwww3mcu/e5kNERMQVqIlNSt3FizBkCHTrZg7lFxERcTUekSANHjyY6tWrM2zYsCKtk5Jx7hzs3AmHD8Pu3VZHIyIikp9HJEiPPPIICxcuLPI6KRk33ADx8eajZ0+roxEREcnPIxKknj17UqVKlSKvk+Lz22+wcWPu8k03wW23WRePiIhIYSxPkNatW8eAAQMICgrCZrOxbNmyfNvExsbSuHFj/Pz8CAsLY/369aUfqDht717o0sWc52jnTqujERERuTbLR7GlpaURGhrKuHHjGDp0aL71ixYtYtKkScTGxtKlSxfefvttIiIiSExMpEGDBgCEhYWR/scZBv9n1apVBAUFFUuc6enpdudITU0tluN6grp1oWlTSE3VzNgiIuIeLE+QIiIiiIiIuOr6mTNnEhkZyfjx4wGYPXs2K1euZO7cuURHRwOwbdu2Eo8zOjqa6dOnl/h5yqKKFeGLL8zfq1WzNBQRERGHWN7EVpiMjAy2bdtGeHi4XXl4eDgbNmwo1VieeuopUlJSch5JSUmlen5388EHEBeXu1ytmpIjERFxH5bXIBXm1KlTZGZmEhgYaFceGBjIsWPHHD5O37592b59O2lpadSrV4+lS5fSvn37a677I19fX3x9fa/vCXmI776D0aOhXDlo2RIKeDlFRERcmksnSNlsNpvdsmEY+coKs3LlSqfWFSQmJoaYmBgyMzOLtJ8n6dIFxo0Df38IC7M6GhERkaJz6QSpZs2aeHl55astOnHiRL5apdIyceJEJk6cSGpqKv7+/pbE4IoyM8FmM2uNbDZ4913zZxHyWBEREZfh0n2QfHx8CAsLIz4+3q48Pj6ezp07WxSV5JWeDn/6Ezz2GBiGWZadKImIiLgjy2uQLly4wL59+3KW9+/fT0JCAgEBATRo0ICoqChGjx5Nu3bt6NSpE/PmzePQoUNMmDDBknjVxJbf2rXw2WdQvjzcfz80b251RCIiItfHZhjZ3/mtsXbtWnoWcL+JsWPHEve/YVCxsbHMmDGD5ORkQkJCmDVrFt26dSvlSO1lN7GlpKRQtWpVS2NxBXPmQLNm0KeP1ZGIiIhcnaOf35YnSO7K0xOkI0fMYfuVKlkdiYiIiOMc/fx26T5IrigmJobg4OACpwLwFL/8Ap06wd13w+XLVkcjIiJS/JQgFdHEiRNJTExky5YtVodimbNn4dQp8wa0p09bHY2IiEjxs7yTtrifTp3g668hOBhq1bI6GhERkeKnGqQi8tQmtuXL4fDh3OXu3ZUciYhI2aVO2k7ypE7an3wCI0eaw/c3bNA91URExH2pk7YUm86doW5d6NoVqlSxOhoREZGSpz5Ick0NGsCWLRAYqNmxRUTEM6gGSfK5fBkeegh++CG3rE4dJUciIuI5lCAVkSd00n7lFXjrLRg4ENLSrI5GRESk9KmTtpPKciftCxdgwACIijJ/ioiIlBWOfn6rD5IAkJ4Ovr7m75Urw+rValITERHPpSY24bffICQEPvoot0zJkYiIeDIlSEJcHOzbB9OnQ0aG1dGIiIhYT01sRRQTE0NMTAyZmZlWh1Jspk0Dw4CHHwYfH6ujERERsZ46aTvJ3Ttp//gjtG6tpjQREfEsmklbruqDDyAsDKZOtToSERER16QEyQNdvAiZmXDoEGRlWR2NiIiI61EfJA90//3QuDH06gXllCKLiIjko49HD5CZCbNnw6VLuWW3367kSERE5Gr0EekBHnwQJk+GkSPN0WoiIiJSOCVIReSO92IbPRqqVoU//Umj1kRERByhYf5Ocrdh/mfOQECA1VGIiIhYS8P8PVhSEvTvD8nJuWVKjkRERBynBKkMGjsWvvwSxo+3OhIRERH3pASpDHr3XejRA+bOtToSERER96R5kMqICxegcmXz9xtvhDVrrI1HRETEnakGqQz4/HMzKdq+3epIREREygYlSG7OMMymtJMn4e23rY5GRESkbFATm5uz2WDJEpgzB554wupoREREygbVIBWRK0wUmZUFGzfmLletCk8/DV5eloUkIiJSpmiiSCdZNVFkZiZERsLChfDppzBsWKmdWkRExO1posgyqlw58PU1f/7+u9XRiIiIlE1KkNyMzQaxsfD99zBmjNXRiIiIlE1KkNzA8ePw2mvmiDUw+xp17GhtTCIiImWZRrG5uEuXoGtX2LvXXJ4yxdp4REREPIFqkFycnx888gg0bgyDBlkdjYiIiGdQguQG/vIX+OknaNrU6khEREQ8gxIkF/TVV2ZtUXp6bln2fdZERESk5ClBcjEpKfDnP8O//gVvvGF1NCIiIp5JnbRdjL+/OQHkxx/D5MlWRyMiIuKZPKIGafDgwVSvXp1heaadTkpKokePHgQHB9O6dWsWL15sUYT2+vSB+fOhfHmrIxEREfFMHpEgPfLIIyxcuDBfube3N7NnzyYxMZF///vfTJ48mbS0NAsiFBEREVfiEQlSz549qVKlSr7yG264gTZt2gBQu3ZtAgICOHPmTClHJyIiIq7G8gRp3bp1DBgwgKCgIGw2G8uWLcu3TWxsLI0bN8bPz4+wsDDWr19f7HFs3bqVrKws6tevX+zHFhEREfdieYKUlpZGaGgoc+bMKXD9okWLmDRpElOnTmXHjh107dqViIgIDh06lLNNWFgYISEh+R5Hjx51KIbTp08zZswY5s2bVyzPSURERNyb5aPYIiIiiIiIuOr6mTNnEhkZyfjx4wGYPXs2K1euZO7cuURHRwOwbds2p8+fnp7O4MGDeeqpp+jcuXOh26X/YWKi1NRUp88pIiIirs3yGqTCZGRksG3bNsLDw+3Kw8PD2bBhw3Uf3zAM7r33Xnr16sXo0aML3TY6Ohp/f/+ch5riREREyi6XTpBOnTpFZmYmgYGBduWBgYEcO3bM4eP07duXu+++m6+++op69eqxZcsWAL7//nsWLVrEsmXLaNOmDW3atGHnzp0FHuOpp54iJSUl55GUlOT8ExMRERGXZnkTmyNsNpvdsmEY+coKs3LlygLLb7vtNrKyshw6hq+vL76+vsTExBATE0NmZqbD5xcRERH34tI1SDVr1sTLyytfbdGJEyfy1SqVlokTJ5KYmJhTCyUiIiJlj0snSD4+PoSFhREfH29XHh8fX2iHahEREZHrYXkT24ULF9i3b1/O8v79+0lISCAgIIAGDRoQFRXF6NGjadeuHZ06dWLevHkcOnSICRMmWBKvmthERETKPpthGIaVAaxdu5aePXvmKx87dixxcXGAOVHkjBkzSE5OJiQkhFmzZtGtW7dSjtReamoq/v7+pKSkULVqVUtjEREREcc4+vlteYLkrpQgiYiIuB9HP79dug+SK4qJiSE4OJj27dtbHYqIiIiUENUgOSklJYVq1aqRlJSkGiQRERE3kZqaSv369Tl37hz+/v5X3c7yTtru6vz58wCaUVtERMQNnT9/vtAESTVITsrKyuLmm29m27ZtDk9a2b59+2vOn5Sd2apmKj9HXj8rWRFfSZ2zOI97PcdyZt+i7uPo9ro2C6brsnTPWVzH9uTr0jAMzp8/T1BQEOXKXb2nkWqQnFSuXDl8fHwKzT7z8vLycvgPWLVqVf0TzqMor58VrIivpM5ZnMe9nmM5s29R9ynq9ro27em6LN1zFtexPf26dOSzW520r8PEiRNLdHux5+qvnxXxldQ5i/O413MsZ/bVdVm6XP31K0vXZXEeW9fltamJzcVo+gAR16RrU8T1lOR1qRokF+Pr68tzzz2Hr6+v1aGIyB/o2hRxPSV5XaoGSURERCQP1SCJiIiI5KEESURERCQPJUgiIiIieShBEhEREclDCZKIiIhIHkqQ3FhSUhI9evQgODiY1q1bs3jxYqtDEhFg8ODBVK9enWHDhlkdiojHWrFiBc2aNeOmm27i3XffLfL+GubvxpKTkzl+/Dht2rThxIkTtG3bll9//ZVKlSpZHZqIR1uzZg0XLlzgvffe47PPPrM6HBGPc+XKFYKDg1mzZg1Vq1albdu2/PDDDwQEBDh8DNUgubEbbriBNm3aAFC7dm0CAgI4c+aMtUGJCD179qRKlSpWhyHisTZv3kzLli2pW7cuVapU4c4772TlypVFOoYSpBK0bt06BgwYQFBQEDabjWXLluXbJjY2lsaNG+Pn50dYWBjr16936lxbt24lKyuL+vXrX2fUImVbaV6XIuKc671Ojx49St26dXOW69Wrx5EjR4oUgxKkEpSWlkZoaChz5swpcP2iRYuYNGkSU6dOZceOHXTt2pWIiAgOHTqUs01YWBghISH5HkePHs3Z5vTp04wZM4Z58+aV+HMScXeldV2KiPOu9zotqPeQzWYrWhCGlArAWLp0qV1Zhw4djAkTJtiVNW/e3HjyyScdPu6lS5eMrl27GgsXLiyOMEU8Skldl4ZhGGvWrDGGDh16vSGKeDxnrtPvv//eGDRoUM66Rx55xPjwww+LdF7VIFkkIyODbdu2ER4eblceHh7Ohg0bHDqGYRjce++99OrVi9GjR5dEmCIepTiuSxEpWY5cpx06dGDXrl0cOXKE8+fP89VXX9G3b98ince72CKWIjl16hSZmZkEBgbalQcGBnLs2DGHjvH999+zaNEiWrdundM++/7779OqVaviDlfEIxTHdQnQt29ftm/fTlpaGvXq1WPp0qW0b9++uMMV8UiOXKfe3t68/vrr9OzZk6ysLB5//HFq1KhRpPMoQbJY3jZRwzAcbie97bbbyMrKKomwRDza9VyXQJFHy4hI0V3rOh04cCADBw50+vhqYrNIzZo18fLyyvet9MSJE/myYhEpHbouRVxfaV2nSpAs4uPjQ1hYGPHx8Xbl8fHxdO7c2aKoRDybrksR11da16ma2ErQhQsX2LdvX87y/v37SUhIICAggAYNGhAVFcXo0aNp164dnTp1Yt68eRw6dIgJEyZYGLVI2abrUsT1ucR1WvQBd+KoNWvWGEC+x9ixY3O2iYmJMRo2bGj4+PgYbdu2Nb799lvrAhbxALouRVyfK1ynuhebiIiISB7qgyQiIiKShxIkERERkTyUIImIiIjkoQRJREREJA8lSCIiIiJ5KEESERERyUMJkoiIiEgeSpBERERE8lCCJCIiIpKHEiQREQecPn2a2rVrc+DAAUvj2LlzJ/Xq1SMtLc3SOETKOiVIIlIqbDZboY97773X6hALFR0dzYABA2jUqBEABw4cwGaz4e3tzZEjR+y2TU5OxtvbG5vN5nBCNWDAAG6//fYC123cuBGbzcb27dtp1aoVHTp0YNasWdfzdETkGpQgiUipSE5OznnMnj2bqlWr2pW98cYbVod4VRcvXuSf//wn48ePz7cuKCiIhQsX2pW999571K1bt0jniIyMZPXq1Rw8eDDfuvnz59OmTRvatm0LwLhx45g7dy6ZmZlFOoeIOE4JkoiUijp16uQ8/P39sdls+coKk11js2TJEnr27EnFihUJDQ1l48aNOdtMmzaNNm3a2O03e/bsnFqfbAsWLKBFixb4+fnRvHlzYmNjCz33119/jbe3N506dcq3buzYsSxYsMCuLC4ujrFjx+bbNjExkTvvvJPKlSsTGBjI6NGjOXXqFAD9+/endu3axMXF2e3z+++/s2jRIiIjI3PK+vbty+nTp/n2228LjVtEnKcESUTcytSpU5kyZQoJCQncfPPNjBgxgitXrji8/zvvvMPUqVP5+9//zs8//8xLL73EM888w3vvvXfVfdatW0e7du0KXDdw4EDOnj3Ld999B8B3333HmTNnGDBggN12ycnJdO/enTZt2rB161a++eYbjh8/zj333AOAt7c3Y8aMIS4uDsMwcvZbvHgxGRkZ/PnPf84p8/HxITQ0lPXr1zv8vEWkaJQgiYhbmTJlCv369ePmm29m+vTpHDx4kH379jm8/wsvvMDrr7/OkCFDaNy4MUOGDGHy5Mm8/fbbV93nwIEDBAUFFbiufPnyjBo1ivnz5wNmc9ioUaMoX7683XZz586lbdu2vPTSSzRv3pxbbrmF+fPns2bNGvbs2QPAfffdx4EDB1i7dm3OfvPnz2fIkCFUr17d7nh169a1vMO4SFmmBElE3Err1q1zfr/hhhsAOHHihEP7njx5kqSkJCIjI6lcuXLO48UXX+S///3vVfe7ePEifn5+V10fGRnJ4sWLOXbsGIsXL+a+++7Lt822bdtYs2aN3XmbN28OkHPu5s2b07lz55xk67///S/r168v8HgVKlTg999/d+h5i0jReVsdgIhIUfyxZsZmswGQlZUFQLly5eyapwAuX76c83v2du+88w4dO3a0287Ly+uq56xZsyZnz5696vqQkBCaN2/OiBEjaNGiBSEhISQkJNhtk5WVxYABA3jllVfy7Z+d6IGZbP3lL38hJiaGBQsW0LBhQ3r37p1vnzNnztCkSZOrxiQi10c1SCJSZtSqVYtjx47ZJUl/TFQCAwOpW7cuv/32G02bNrV7NG7c+KrHveWWW0hMTCz03Pfddx9r164tsLYHoG3btuzevZtGjRrlO3elSpVytrvnnnvw8vLio48+4r333mPcuHE5ieAf7dq1i1tuuaXQmETEeUqQRKTM6NGjBydPnmTGjBn897//JSYmhq+//tpum2nTphEdHc0bb7zBnj172LlzJwsWLGDmzJlXPW7fvn3ZvXt3obVI999/PydPnixwKgCAiRMncubMGUaMGMHmzZv57bffWLVqFffdd5/dcP3KlSszfPhwnn76aY4ePVrg/FAHDhzgyJEjV503SUSunxIkESkzWrRoQWxsLDExMYSGhrJ582amTJlit8348eN59913iYuLo1WrVnTv3p24uLhCa5BatWpFu3bt+PTTT6+6jbe3NzVr1sTbu+CeC0FBQXz//fdkZmbSt29fQkJCePTRR/H396dcOft/xZGRkZw9e5bbb7+dBg0a5DvWxx9/THh4OA0bNizs5RCR62Az8jbYi4hIPl999RVTpkxh165d+RKa0pSens5NN93Exx9/TJcuXSyLQ6SsUydtEREH3Hnnnezdu5cjR45Qv359y+I4ePAgU6dOVXIkUsJUgyQiLuGll17ipZdeKnBd165d8/UlEhEpSUqQRMQlnDlzhjNnzhS4rkKFCkW+t5mIyPVQgiQiIiKSh0axiYiIiOShBElEREQkDyVIIiIiInkoQRIRERHJQwmSiIiISB5KkERERETyUIIkIiIiksf/A74t4fgym7RUAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "print(\"rho_nue_linx=\", np.array(rho_nue_std))\n", - "print(\"rho_nue_nudec=\", np.array(rho_nue_nudec))\n", - "\n", - "\n", - "\n", - "rho_nue_difference = np.array(rho_nue_std) - np.array(rho_nue_nudec) \n", - "rho_nue_residuals = rho_nue_difference / np.array(rho_nue_nudec)\n", - "print(\"rho_nue_residuals=\", rho_nue_residuals)\n", - "plt.loglog(T_nue, rho_nue_residuals, label=\"residuals\", color='blue', linestyle='dotted')\n", - "plt.xlabel(\"T_nue (MeV)\")\n", - "plt.ylabel(\"residuals\")\n", - "plt.title(\"residuals of rho_nue vs. T_nue for mu_nue={}\".format(mu))\n", - "plt.show()\n", - "\n", - "T_nue_log = np.log10(T_nue)\n", - "rho_nue_residuals_log = np.log10(rho_nue_residuals)\n", - "\n", - "plt.plot(T_nue_log, rho_nue_residuals_log, label=\"rho_nue_std, reconstructed log plot\",color='green', linestyle='dashed')\n", - "plt.xlabel(\"T_nue (MeV)\")\n", - "plt.ylabel(\"rho_nue_residuals (MeV^4)\")\n", - "plt.title(\"rho_nue vs. T_nue for mu_nue={}\".format(mu))\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "id": "98e368ce", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'rho_nue vs. T_nue for mu_nue=1, linear plot')" - ] - }, - "execution_count": 89, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.loglog(T_nue, rho_nue_residuals, label=\"rho_nue_std, reconstructed\",color='red', linestyle='dashed')\n", - "plt.xlabel(\"T_nue (MeV)\")\n", - "plt.ylabel(\"rho_nue_residuals (MeV^4)\")\n", - "plt.title(\"rho_nue vs. T_nue for mu_nue={}, linear plot\".format(mu))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2fccbf7f", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.15" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 17ee3ccdc649c36c364d778da7139e58ebfd301f Mon Sep 17 00:00:00 2001 From: cgiovanetti <52010580+cgiovanetti@users.noreply.github.com> Date: Mon, 31 Aug 2026 13:26:16 -0700 Subject: [PATCH 6/7] Delete graphing 6.26.ipynb --- graphing 6.26.ipynb | 72 --------------------------------------------- 1 file changed, 72 deletions(-) delete mode 100644 graphing 6.26.ipynb diff --git a/graphing 6.26.ipynb b/graphing 6.26.ipynb deleted file mode 100644 index 01b865d..0000000 --- a/graphing 6.26.ipynb +++ /dev/null @@ -1,72 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 6, - "id": "caf8ee34-cf90-4187-a792-b256ca68bcbc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - }, - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'jax'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 6\u001b[39m\n\u001b[32m 3\u001b[39m get_ipython().run_line_magic(\u001b[33m'\u001b[39m\u001b[33mautoreload\u001b[39m\u001b[33m'\u001b[39m, \u001b[33m'\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m 4\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mlinx\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mconst\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mconst\u001b[39;00m \n\u001b[32m 7\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mlinx\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mnuclear\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m NuclearRates\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mlinx\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mbackground\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m BackgroundModel\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\LINX-original\\linx\\const.py:1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjax\u001b[39;00m\n\u001b[32m 2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjax\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjnp\u001b[39;00m\n\u001b[32m 3\u001b[39m jax.config.update(\u001b[33m\"\u001b[39m\u001b[33mjax_enable_x64\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;66;03m# need this to enable float64\u001b[39;00m\n", - "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'jax'" - ] - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "%load_ext autoreload\n", - "%autoreload\n", - "import numpy as np\n", - "\n", - "import linx.const as const \n", - "from linx.nuclear import NuclearRates\n", - "from linx.background import BackgroundModel\n", - "from linx.abundances import AbundanceModel" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b3deb468-af18-4607-85cf-cb2e5c9f43d8", - "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.13.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 20bf5b8384144370be76b5e626aa6c70bed45d83 Mon Sep 17 00:00:00 2001 From: cgiovanetti <52010580+cgiovanetti@users.noreply.github.com> Date: Mon, 31 Aug 2026 13:27:24 -0700 Subject: [PATCH 7/7] revert to old imports in const --- linx/const.py | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/linx/const.py b/linx/const.py index f70dc14..9fb4f99 100644 --- a/linx/const.py +++ b/linx/const.py @@ -1,11 +1,6 @@ -try: - import jax - import jax.numpy as jnp - jax.config.update("jax_enable_x64", True) # need this to enable float64 -except ImportError: - import numpy as np - jnp = np - jax = None +import jax +import jax.numpy as jnp +jax.config.update("jax_enable_x64", True) # need this to enable float64 from linx.special_funcs import zeta_3 @@ -129,4 +124,4 @@ # T_Middle to T_switch: small network always sufficient. T_switch = 1.25e9 * kB # MeV # T_switch to T_end: turn on full network if desired. -T_end = 6.e7 * kB # MeV \ No newline at end of file +T_end = 6.e7 * kB # MeV