diff --git a/.gitignore b/.gitignore index 57ae03e..df9e108 100644 --- a/.gitignore +++ b/.gitignore @@ -9,4 +9,6 @@ build __pycache__ pyhyrec.egg-info -dist \ No newline at end of file +dist + +example_pmf.ipynb \ No newline at end of file diff --git a/README.md b/README.md index eb1af44..b1c9a41 100644 --- a/README.md +++ b/README.md @@ -32,7 +32,7 @@ In this fork we have implement a lightweight python wrapper for HYREC-2 using cy pip install hyrec ``` -## How to run HYREC-2 +### How to run HYREC-2 An example of notebook using the python wrapper is given [here](https://github.com/gaetanfacchinetti/HYREC-2/blob/master/example.ipynb). diff --git a/example.ipynb b/example.ipynb index 9c82f45..4ce8fbc 100644 --- a/example.ipynb +++ b/example.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -40,7 +40,28 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([9.39846976e-01, 1.74273336e+00, 2.71873230e+00, ...,\n", + " 2.18012745e+04, 2.18040000e+04, 2.18067255e+04])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Tm_pbh" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -54,9 +75,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.000e+00, 2.000e+00, 3.000e+00, ..., 7.998e+03, 7.999e+03,\n", + " 8.000e+03])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z_c" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# plotting xe\n", "fig = plt.figure()\n", @@ -73,6 +136,13 @@ "ax.legend()" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/example.py b/example.py index 2dab03b..e2244bd 100644 --- a/example.py +++ b/example.py @@ -2,7 +2,55 @@ import numpy as np import pyhyrec as pyhy -inj_params = pyhy.init_INPUT_INJ_PARAMS(0., 0., 0., 0., 0., 0., 0., 0, 0., 1., 0.) -cosmo_params = pyhy.init_INPUT_COSMOPARAMS(6.735837e-01, 2.7255, 0.0494142797907188, 0.31242079216478097, 0., -1, 0, 3.046, 1.0, 0.06, 0., 0., 0.245, 1., 1.) +cosmo = pyhy.HyRecCosmoParams() +inj = pyhy.HyRecInjectionParams() -z, xe, Tm = pyhy.call_run_hyrec(cosmo_params, inj_params) +z, xe, Tm = pyhy.call_run_hyrec(cosmo(), inj()) + +# load data for comparisons to the precomputed default case +data = np.loadtxt("./tests/output_xe.dat") + +z_c = np.flip(data[:, 0]) +xe_c = np.flip(data[:, 1]) +Tm_c = np.flip(data[:, 2]) + + +# create a cosmo params and injection params object with Primordial Black Holes +inj_pbh = pyhy.HyRecInjectionParams({'fpbh' : 1.0, 'Mpbh': 1e+3}) +z_pbh, xe_pbh, Tm_pbh = pyhy.call_run_hyrec(cosmo(), inj_pbh()) + + +# plotting xe +fig = plt.figure() +ax = fig.gca() + +ax.plot(z, xe, '-b', label='without pbh') +ax.plot(z_pbh, xe_pbh, '-r', label='with pbh') +ax.plot(z_c, xe_c, 'c-.', label='without pbh (default)') + +ax.set_xscale("log") +ax.set_yscale("log") +ax.set_ylabel('xe') +ax.set_xlabel('z') +ax.legend() + +fig.savefig("../test_xe.pdf") + + +# plotting Tm +fig = plt.figure() +ax = fig.gca() + +ax.plot(z, Tm, '-b', label='without pbh') +ax.plot(z_pbh, Tm_pbh, '-r', label='with pbh') +ax.plot(z_c, Tm_c, 'c-.', label='without pbh (default)') +ax.plot(z, cosmo.T0 * (1+z), color='k', linestyle=':', label='CMB temp.') + +ax.set_xscale("log") +ax.set_yscale("log") +ax.set_ylabel('Tm [K]') +ax.set_xlabel('z') +ax.legend() + + +fig.savefig("../test_TK.pdf") \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index a5b30b5..7c7094f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,6 +4,7 @@ requires = ["setuptools>=61.0.0", "wheel", "cython"] build-backend = "setuptools.build_meta" + [project] name = "pyhyrec" version = "1.0.0" @@ -34,4 +35,5 @@ PythonVersion = "https://github.com/gaetanfacchinetti/HYREC-2" [tool.pytest.ini_options] minversion = "6.0" -testpaths = ["tests"] \ No newline at end of file +testpaths = ["tests"] + diff --git a/setup.py b/setup.py index fd4a5e5..1516621 100644 --- a/setup.py +++ b/setup.py @@ -1,28 +1,39 @@ import subprocess import os -# go to where the project needs to be compiled -os.chdir("./src/pyhyrec/src/") +from setuptools import setup, Extension +from Cython.Build import cythonize -try: - subprocess.run(['make'], check=True) - print("make executed successfully.") +def main(): - # Run the 'make' command with the desired target - subprocess.run(['make', 'clean'], check=True) - print("make clean executed successfully.") + # go to where the project needs to be compiled + + os.chdir("./src/pyhyrec/src/") -except subprocess.CalledProcessError as e: - print("Error executing Makefile:", e) + try: + + if os.path.exists("libhyrec.so"): + os.remove("libhyrec.so") -# go back to the main project folder -os.chdir("../../../") + subprocess.run(['make'], check=True) + print("make executed successfully.") -from setuptools import setup, Extension -from Cython.Build import cythonize + # Run the 'make' command with the desired target + subprocess.run(['make', 'clean'], check=True) + print("make clean executed successfully.") + + except subprocess.CalledProcessError as e: + print("Error executing Makefile:", e) -cythonize("./src/pyhyrec/wrapperhyrec.pyx", force = True) + # go back to the main project folder + os.chdir("../../../") + + #extensions = [Extension("pyhyrec.src.hyrec", sources = ["./src/pyhyrec/src/hyrec.c"])] + extensions = [Extension("pyhyrec.wrapperhyrec", sources = ["./src/pyhyrec/wrapperhyrec.c"], libraries = ["hyrec"], library_dirs=["./src/pyhyrec/src/"], build_temp="src/pyhyrec/")] + cythonize("./src/pyhyrec/wrapperhyrec.pyx", force = True) + + setup(ext_modules=extensions, package_dir={'' : 'src'}, packages=['pyhyrec'], package_data= {'pyhyrec' :['data/*']}, include_package_data=True) -extensions = [Extension("pyhyrec.wrapperhyrec", sources = ["./src/pyhyrec/wrapperhyrec.c"], libraries = ["hyrec"], library_dirs=["./src/pyhyrec/src/"], build_temp="src/pyhyrec/")] -setup(ext_modules=extensions, package_dir={'': 'src'}, packages=['pyhyrec'], package_data= {'pyhyrec' :['data/*']}, include_package_data=True) \ No newline at end of file +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/pyhyrec.egg-info/PKG-INFO b/src/pyhyrec.egg-info/PKG-INFO index 68f6bbe..39e8145 100644 --- a/src/pyhyrec.egg-info/PKG-INFO +++ b/src/pyhyrec.egg-info/PKG-INFO @@ -728,7 +728,7 @@ In this fork we have implement a lightweight python wrapper for HYREC-2 using cy pip install hyrec ``` -## How to run HYREC-2 +### How to run HYREC-2 An example of notebook using the python wrapper is given [here](https://github.com/gaetanfacchinetti/HYREC-2/blob/master/example.ipynb). diff --git a/src/pyhyrec.egg-info/SOURCES.txt b/src/pyhyrec.egg-info/SOURCES.txt index 64121dd..c0575d7 100644 --- a/src/pyhyrec.egg-info/SOURCES.txt +++ b/src/pyhyrec.egg-info/SOURCES.txt @@ -4,11 +4,13 @@ README.md pyproject.toml setup.py ./src/pyhyrec/wrapperhyrec.c +./src/pyhyrec/src/hyrec.c src/pyhyrec/.DS_Store src/pyhyrec/__init__.py src/pyhyrec/__main__.py src/pyhyrec/params.py src/pyhyrec/wrapperhyrec.c +src/pyhyrec/wrapperhyrec.cpython-310-darwin.so src/pyhyrec/wrapperhyrec.pyx src/pyhyrec.egg-info/PKG-INFO src/pyhyrec.egg-info/SOURCES.txt @@ -21,19 +23,4 @@ src/pyhyrec/data/__init__.py src/pyhyrec/data/fit_swift.dat src/pyhyrec/data/two_photon_tables.dat src/pyhyrec/data/two_photon_tables_hires.dat -src/pyhyrec/src/Makefile -src/pyhyrec/src/energy_injection.c -src/pyhyrec/src/energy_injection.h -src/pyhyrec/src/helium.c -src/pyhyrec/src/helium.h -src/pyhyrec/src/history.c -src/pyhyrec/src/history.h -src/pyhyrec/src/hydrogen.c -src/pyhyrec/src/hydrogen.h -src/pyhyrec/src/hyrec -src/pyhyrec/src/hyrec.c -src/pyhyrec/src/hyrectools.c -src/pyhyrec/src/hyrectools.h -src/pyhyrec/src/input.dat -src/pyhyrec/src/libhyrec.so tests/test.py \ No newline at end of file diff --git a/src/pyhyrec/__init__.py b/src/pyhyrec/__init__.py index 3bff58b..1d9dac8 100644 --- a/src/pyhyrec/__init__.py +++ b/src/pyhyrec/__init__.py @@ -1,3 +1,8 @@ -from .wrapperhyrec import (init_INPUT_COSMOPARAMS, init_INPUT_INJ_PARAMS, call_run_hyrec) +from .wrapperhyrec import ( + init_INPUT_COSMOPARAMS, + init_INPUT_INJ_PARAMS, + call_run_hyrec, + call_decay_rate_pmf_turbulences, + ) from .params import HyRecCosmoParams, HyRecInjectionParams \ No newline at end of file diff --git a/src/pyhyrec/src/energy_injection.c b/src/pyhyrec/src/energy_injection.c index 5518b24..44c6dab 100644 --- a/src/pyhyrec/src/energy_injection.c +++ b/src/pyhyrec/src/energy_injection.c @@ -66,12 +66,17 @@ double dEdtdV_DM_ann(double z, INJ_PARAMS *params){ /*************************************************************************************** Effect of primordial magnetic fields -According to Chluba et al. 2015 +According to Kunze and Komatzu 2014 ***************************************************************************************/ -// Energy injection rate due to turbulences -// H must be in 1/s for a result in eV / cm^3 / s -double gamma_turbulences(double z, double H, double B0, double nB) +/* Mode for a magnetic field with variance sigB0 (nG) on scale lambda (Mpc), normalisation sig, and power index nB */ +double pmf_mode(double sigB0, double nB, double sig, double lambda) +{ + return 2 * M_PI * pow(pow(sigB0 / sig, 2) * pow(lambda / 2.0 / M_PI, 3.0 + nB), -1.0/(5.0+nB)); +} + +// Energy injection rate due to turbulences in units of Hubble time +double decay_rate_pmf_turbulences(double z, double tdti, double nB) { double zi = 1088; @@ -79,11 +84,7 @@ double gamma_turbulences(double z, double H, double B0, double nB) return 0; double m = 2.0*(nB+3.0)/(nB + 5.0); - double kd = 286.91 * B0; - double titd = 14.8 / B0 / kd; - double rhoB = 9.5e-8 * square(B0) * 0.26 * pow(1+z, 4); - - return 3.0*m/2.0 * pow(log(1+titd), m)/pow(log(1+titd) + 1.5 * log((1+zi)/(1+z)), m+1) * H * rhoB; + return 3.0*m/2.0 * pow(log(1+tdti), m)/pow(log(1+tdti) + 1.5 * log((1+zi)/(1+z)), m+1); } @@ -233,49 +234,4 @@ double dEdtdV_inj(double z, double xe, double Tgas, INJ_PARAMS *params){ } -/********************************************************************************** -Energy *deposition* rate per unit volume -Essentially use a very simple ODE solution -**********************************************************************************/ - -void update_dEdtdV_dep(double z_out, double dlna, double xe, double Tgas, - double nH, double H, INJ_PARAMS *params, double *dEdtdV_dep) { - - double inj = dEdtdV_inj(z_out, xe, Tgas, params); - - if (params->on_the_spot == 1) *dEdtdV_dep = inj; - - // Else put in your favorite recipe to translate from injection to deposition - // Here I assume injected photon spectrum Compton cools at rate dE/dt = - 0.1 n_h c sigma_T E - // This is valid for E_photon ~ MeV or so. - - else { // c sigma_T = 2e-14 (cgs) - *dEdtdV_dep = (*dEdtdV_dep *exp(-7.*dlna) + 2e-15* dlna*nH/H *inj) - /(1.+ 2e-15 *dlna*nH/H); - } -} - -/******************************************************************************* -Fraction of energy deposited in the form of heat, ionization and excitations -*******************************************************************************/ - -double chi_heat(double xe) { - return (1.+2.*xe)/3.; // Approximate value of Chen & Kamionkowski 2004 - - // fit by Vivian Poulin of columns 1 and 2 in Table V of Galli et al. 2013 - // overall coefficient slightly changed by YAH so it reaches exactly 1 at xe = 1. - // return (xe < 1.? 1.-pow(1.-pow(xe,0.300134),1.51035) : 1.); -} - -double chi_ion(double xe) { - return (1.-xe)/3.; // Approximate value of Chen & Kamionkowski 2004 - - // fit by Vivian Poulin of columns 1 and 4 in Table V of Galli et al. 2013 - // return 0.369202*pow(1.-pow(xe,0.463929),1.70237); -} - -double chi_exc(double xe) { - return 1. - chi_ion(xe) - chi_heat(xe); -} - diff --git a/src/pyhyrec/src/energy_injection.h b/src/pyhyrec/src/energy_injection.h index e58c7a2..9838d3c 100644 --- a/src/pyhyrec/src/energy_injection.h +++ b/src/pyhyrec/src/energy_injection.h @@ -22,11 +22,12 @@ typedef struct { int on_the_spot; /* if set to 1 assume energy deposition rate = injection rate */ /* Otherwise solves for deposition given injection with simple recipe */ - double ion, exclya; + double ion, exclya, dEdtdV_heat; /* Adding the possibility to have a heating decorrelated from ion and exclya */ } INJ_PARAMS; -void update_dEdtdV_dep(double z_out, double dlna, double xe, double Tgas, - double nH, double H, INJ_PARAMS *params, double *dEdtdV_dep); + +double dEdtdV_inj(double z, double xe, double Tgas, INJ_PARAMS *params); +double decay_rate_pmf_turbulences(double z, double tdti, double nB); /* decay rate of PMF turbulences*/ #endif diff --git a/src/pyhyrec/src/history.c b/src/pyhyrec/src/history.c index db34d04..78effaa 100644 --- a/src/pyhyrec/src/history.c +++ b/src/pyhyrec/src/history.c @@ -282,7 +282,7 @@ The input and output temperatures are in KELVIN. Added December 2014: possibility for additional energy deposition dEdtdV in eV/s/cm^3. ******************************************************************************************/ -double rec_Tmss(double z, double xe, REC_COSMOPARAMS *cosmo, double dEdtdV, double H) { +double rec_Tmss(double z, double xe, REC_COSMOPARAMS *cosmo, double dEdtdV_heat, double H) { double fsR = cosmo->fsR; double meR = cosmo->meR; @@ -293,7 +293,7 @@ double rec_Tmss(double z, double xe, REC_COSMOPARAMS *cosmo, double dEdtdV, doub /* Here Tr, Tm are the actual (not rescaled) temperatures */ double coeff = fsR*fsR/meR/meR/meR*4.91466895548409e-22*Tr*Tr*Tr*Tr*xe/(1.+xe+cosmo->fHe)/H; double Tm = Tr/(1.+1./coeff) - + (1.+2.*xe)/3.*dEdtdV/kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H /(1.+coeff); + + dEdtdV_heat/kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H /(1.+coeff); return Tm; } @@ -305,27 +305,28 @@ Corrected June 2016: in the presence of heating, Tm can cross Tr, so added a cri for returning -Tr when quasi-steady state. Note: this is not very "clean", there should be some flag for quasi-steady-state, will eventually fix. Added December 2014: possibility of additional energy deposition dEdtdV in eV/s/cm^3. +Added March 2024: possibility of additional heating instead of global energy injection ******************************************************************************************/ -double rec_dTmdlna(double z, double xe, double Tm, REC_COSMOPARAMS *cosmo, double dEdtdV, double H) { +double rec_dTmdlna(double z, double xe, double Tm, REC_COSMOPARAMS *cosmo, double dEdtdV_heat, double H) { double fsR = cosmo->fsR; double meR = cosmo->meR; double Tr = cosmo->T0 *(1.+z); double nH = cosmo->nH0 *cube(1.+z); return ( (Tr/Tm-1.<1e-10 && Tr > 3000.) ? -Tr : -2.*Tm + fsR*fsR/meR/meR/meR*4.91466895548409e-22*Tr*Tr*Tr*Tr*xe/(1.+xe+cosmo->fHe)*(Tr-Tm)/H - + (1.+2.*xe)/3. *dEdtdV /kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H); + + dEdtdV_heat /kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H); /* Coefficient = 8 sigma_T a_r / (3 m_e c) */ /* Here Tr, Tm are the actual (not rescaled) temperatures */ } -double Tm_implicit(double z, double xe, double Tm, REC_COSMOPARAMS *cosmo, double dEdtdV, double H, double DLNA) { +double Tm_implicit(double z, double xe, double Tm, REC_COSMOPARAMS *cosmo, double dEdtdV_heat, double H, double DLNA) { double fsR = cosmo->fsR; double meR = cosmo->meR; double Tr = cosmo->T0 *(1.+z); double nH = cosmo->nH0 *cube(1.+z); double gamma = fsR*fsR/meR/meR/meR*4.91466895548409e-22*Tr*Tr*Tr*Tr*xe/(1.+xe+cosmo->fHe)/H; - return (Tm + DLNA*(gamma*Tr + (1.+2.*xe)/3. *dEdtdV /kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H) )/ ( 1.+(2.+gamma)*DLNA ); + return (Tm + DLNA*(gamma*Tr + dEdtdV_heat /kBoltz /(1.5 *nH*(1.+xe+cosmo->fHe))/H) )/ ( 1.+(2.+gamma)*DLNA ); } @@ -558,7 +559,7 @@ void rec_get_xe_next1_H(HYREC_DATA *data, int model, double z_in, long iz, doubl long iz_rad = iz-1-data->rad->iz_rad_0; double dxedlna, z_out; - double nH, TR, xH1, dEdtdV, DLNA; + double nH, TR, xH1, dEdtdV_heat, DLNA; char sub_message[SIZE_ErrorM]; if (flag==10) DLNA = cosmo->dlna; else DLNA = cosmo->dlna/10.; @@ -567,7 +568,7 @@ void rec_get_xe_next1_H(HYREC_DATA *data, int model, double z_in, long iz, doubl nH = cosmo->nH0 *cube(1.+z_in); TR = kBoltz *cosmo->T0 *(1.+z_in); - dEdtdV = cosmo->inj_params->ion*3*nH*EI / (1-xe_in); + dEdtdV_heat = cosmo->inj_params->dEdtdV_heat; /* Compute dxHII/dlna. This also correctly updates the radiation field at z_in, which is required even when using the stiff approximation */ @@ -586,7 +587,7 @@ void rec_get_xe_next1_H(HYREC_DATA *data, int model, double z_in, long iz, doubl } /* Quasi-steady state solution for Tm */ - *Tm_out = rec_Tmss(z_out, *xe_out, cosmo, dEdtdV, H); + *Tm_out = rec_Tmss(z_out, *xe_out, cosmo, dEdtdV_heat, H); // Test that the outcome is sensible if (*xe_out > 1. || *xe_out < 0. || *xe_out != *xe_out) { @@ -620,13 +621,14 @@ void rec_get_xe_next2_HTm(HYREC_DATA *data, int model, double z_in, long iz, dou int *error = &data->error; long iz_rad = iz-1-data->rad->iz_rad_0; - double dxedlna, dTmdlna, nH, TR, dEdtdV, DLNA; + double dxedlna, dTmdlna, nH, TR, dEdtdV_heat, DLNA; char sub_message[SIZE_ErrorM]; DLNA = cosmo->dlna; nH = cosmo->nH0 *cube(1.+z_in); TR = kBoltz *cosmo->T0 *(1.+z_in); - dEdtdV = cosmo->inj_params->ion*3*nH*EI / (1-xe_in); + dEdtdV_heat = cosmo->inj_params->dEdtdV_heat; + /*For low redshifts (z < 20 or so) use Peeble's model. The precise model does not metter much here as 1) the free electron fraction is basically zero (~1e-4) in any case and @@ -636,7 +638,7 @@ void rec_get_xe_next2_HTm(HYREC_DATA *data, int model, double z_in, long iz, dou || kBoltz*Tm_in/TR <= T_RATIO_MIN) model = PEEBLES; dxedlna = rec_dxHIIdlna(data, model, xe_in, xe_in, nH, H, kBoltz*Tm_in, TR, iz_rad, z_in); - dTmdlna = rec_dTmdlna(z_in, xe_in, Tm_in, cosmo, dEdtdV, H); + dTmdlna = rec_dTmdlna(z_in, xe_in, Tm_in, cosmo, dEdtdV_heat, H); data->Tm_evolve_implicit = 1; if (fabs(1-dTmdlna_prev[0]/dTmdlna)Tm_evolve_implicit = 0; @@ -644,7 +646,7 @@ void rec_get_xe_next2_HTm(HYREC_DATA *data, int model, double z_in, long iz, dou dTmdlna_prev[0] = dTmdlna; dTmdlna_prev[1] = dTmdlna_prev[0]; data->xe_output[iz] = xe_in + DLNA *hyrec_integrator(dxedlna, dxedlna_prev, z_in); - data->Tm_output[iz] = Tm_implicit(z_out, data->xe_output[iz], Tm_in, cosmo, dEdtdV, H_next, DLNA); + data->Tm_output[iz] = Tm_implicit(z_out, data->xe_output[iz], Tm_in, cosmo, dEdtdV_heat, H_next, DLNA); } else { data->xe_output[iz] = xe_in + DLNA *hyrec_integrator(dxedlna, dxedlna_prev, z_in); @@ -683,6 +685,7 @@ char* rec_build_history(HYREC_DATA *data, int model, double *hubble_array){ double z, dz, DLNA, Delta_xe, xHeII, xH1, dEdtdV_dep, nH, H; double *ion = &cosmo->inj_params->ion; double *exclya = &cosmo->inj_params->exclya; + double *dEdtdV_heat = &cosmo->inj_params->dEdtdV_heat; double z_out=0., H_next; int flag=10; double xe_i, Tm_i; @@ -783,9 +786,9 @@ char* rec_build_history(HYREC_DATA *data, int model, double *hubble_array){ if (hubble_array[0]==-1.) H = rec_HubbleRate(cosmo, z); else H = rec_interp1d(.0, dz, hubble_array, Nz, z, error, data->error_message); - update_dEdtdV_dep(z, DLNA, xe_output[iz-1], Tm_output[iz-1], nH, H, cosmo->inj_params, &dEdtdV_dep); - *ion = dEdtdV_dep/3. /nH *xH1 /EI; - *exclya = *ion /0.75; + update_dEdtdV_dep(z, DLNA, xe_output[iz-1], Tm_output[iz-1], nH, xH1, H, cosmo, &dEdtdV_dep, ion, exclya, dEdtdV_heat); + //*ion = dEdtdV_dep/3. /nH * xH1 /EI; + //*exclya = *ion / 0.75; for(; z >= 0. && xHeII > XHEII_MIN; iz++) { @@ -798,10 +801,10 @@ char* rec_build_history(HYREC_DATA *data, int model, double *hubble_array){ else H = rec_interp1d(.0, dz, hubble_array, Nz, z, error, data->error_message); nH = cosmo->nH0*cube(1.+z); - Tm_output[iz] = rec_Tmss(z, xe_output[iz], cosmo, dEdtdV_dep, H); - update_dEdtdV_dep(z, DLNA, xe_output[iz], Tm_output[iz], nH, H, cosmo->inj_params, &dEdtdV_dep); - *ion = dEdtdV_dep/3. /nH *xH1 /EI; - *exclya = *ion /0.75; + Tm_output[iz] = rec_Tmss(z, xe_output[iz], cosmo, *dEdtdV_heat, H); + update_dEdtdV_dep(z, DLNA, xe_output[iz], Tm_output[iz], nH, xH1, H, cosmo, &dEdtdV_dep, ion, exclya, dEdtdV_heat); + //*ion = dEdtdV_dep/3. /nH *xH1 /EI; + //*exclya = *ion /0.75; if (*error == 1) return data->error_message; } @@ -824,9 +827,9 @@ char* rec_build_history(HYREC_DATA *data, int model, double *hubble_array){ if (hubble_array[0]==-1.) H = rec_HubbleRate(cosmo, z); else H = rec_interp1d(.0, dz, hubble_array, Nz, z, error, data->error_message); - update_dEdtdV_dep(z, DLNA/10., xe_i, Tm_i, nH, H, cosmo->inj_params, &dEdtdV_dep); - *ion = dEdtdV_dep/3. /nH *(1.-xe_i) /EI; - *exclya = *ion /0.75; + update_dEdtdV_dep(z, DLNA/10., xe_i, Tm_i, nH, (1.-xe_i), H, cosmo, &dEdtdV_dep, ion, exclya, dEdtdV_heat); + //*ion = dEdtdV_dep/3. /nH *(1.-xe_i) /EI; + //*exclya = *ion /0.75; } xe_output[iz] = xe_i; Tm_output[iz] = Tm_i; dxHIIdlna_prev[1] = (xe_output[iz-1] - xe_output[iz-3])/2./DLNA; @@ -849,9 +852,9 @@ char* rec_build_history(HYREC_DATA *data, int model, double *hubble_array){ if (hubble_array[0]==-1.) H = rec_HubbleRate(cosmo, z); else H = rec_interp1d(.0, dz, hubble_array, Nz, z, error, data->error_message); - update_dEdtdV_dep(z, DLNA, xe_output[iz], Tm_output[iz], nH, H, cosmo->inj_params, &dEdtdV_dep); - *ion = dEdtdV_dep/3. /nH *(1.-xe_output[iz]) /EI; - *exclya = *ion /0.75; + update_dEdtdV_dep(z, DLNA, xe_output[iz], Tm_output[iz], nH, (1.-xe_output[iz]), H, cosmo, &dEdtdV_dep, ion, exclya, dEdtdV_heat); + //*ion = dEdtdV_dep/3. /nH *(1.-xe_output[iz]) /EI; + //*exclya = *ion /0.75; } if (*error == 1) return data->error_message; } @@ -889,9 +892,9 @@ char* rec_build_history(HYREC_DATA *data, int model, double *hubble_array){ else H_next = H; } nH = cosmo->nH0*cube(1.+z); - update_dEdtdV_dep(z, DLNA, xe_output[iz], Tm_output[iz], nH, H, cosmo->inj_params, &dEdtdV_dep); - *ion = dEdtdV_dep/3. /nH *(1.-xe_output[iz]) /EI; - *exclya = *ion /0.75; + update_dEdtdV_dep(z, DLNA, xe_output[iz], Tm_output[iz], nH, (1.-xe_output[iz]), H, cosmo, &dEdtdV_dep, ion, exclya, dEdtdV_heat); + //*ion = dEdtdV_dep/3. /nH *(1.-xe_output[iz]) /EI; + //*exclya = *ion /0.75; if (*error == 1) return data->error_message; } diff --git a/src/pyhyrec/src/hydrogen.c b/src/pyhyrec/src/hydrogen.c index 233f174..bb678b7 100644 --- a/src/pyhyrec/src/hydrogen.c +++ b/src/pyhyrec/src/hydrogen.c @@ -36,6 +36,51 @@ #include "hydrogen.h" + +/******************************************************************************* +Fraction of energy deposited in the form of heat, ionization and excitations +*******************************************************************************/ + +double chi_heat(double xe) { + return (1.+2.*xe)/3.; // Approximate value of Chen & Kamionkowski 2004 + + // fit by Vivian Poulin of columns 1 and 2 in Table V of Galli et al. 2013 + // overall coefficient slightly changed by YAH so it reaches exactly 1 at xe = 1. + //return (xe < 1.? 1.-pow(1.-pow(xe,0.300134),1.51035) : 1.); +} + + +/********************************************************************************** +Energy *deposition* rate per unit volume +Essentially use a very simple ODE solution +**********************************************************************************/ + +void update_dEdtdV_dep(double z_out, double dlna, double xe, double Tgas, + double nH, double xH, double H, REC_COSMOPARAMS *params, double *dEdtdV_dep, + double *ion, double *exclya, double *dEdtdV_heat) { + + double inj = dEdtdV_inj(z_out, xe, Tgas, params->inj_params); + + if (params->inj_params->on_the_spot == 1) *dEdtdV_dep = inj; + + // Else put in your favorite recipe to translate from injection to deposition + // Here I assume injected photon spectrum Compton cools at rate dE/dt = - 0.1 n_h c sigma_T E + // This is valid for E_photon ~ MeV or so. + + else { // c sigma_T = 2e-14 (cgs) + *dEdtdV_dep = (*dEdtdV_dep *exp(-7.*dlna) + 2e-15* dlna*nH/H *inj) + /(1.+ 2e-15 *dlna*nH/H); + } + + *ion = *dEdtdV_dep / 3. / nH * xH /EI; + *exclya = *ion / 0.75; + *dEdtdV_heat = *dEdtdV_dep * chi_heat(xe); +} + + + + + /*********************************************************************************************************** Some constants appropriately rescaled for different values of the fine-structure constant and electron mass ***********************************************************************************************************/ diff --git a/src/pyhyrec/src/hydrogen.h b/src/pyhyrec/src/hydrogen.h index 7a25183..d5c1347 100644 --- a/src/pyhyrec/src/hydrogen.h +++ b/src/pyhyrec/src/hydrogen.h @@ -217,6 +217,9 @@ double rec_HMLA_2photon_dxedlna(HYREC_DATA *data, double xe, double nH, double H double rec_dxHIIdlna(HYREC_DATA *data, int model, double xe, double xHII, double nH, double H, double TM, double TR, unsigned iz, double z); +void update_dEdtdV_dep(double z_out, double dlna, double xe, double Tgas, + double nH, double xH, double H, REC_COSMOPARAMS *params, double *dEdtdV_dep, + double *dEdtdV_ion, double *dEdtdV_exclya, double *dEdtdV_heat); /************ SWITCHES FOR RADIATIVE TRANSFER. ALL SWITCHES SET TO 1 ARE THE DEFAULT MODEL ************/ diff --git a/src/pyhyrec/wrapperhyrec.c b/src/pyhyrec/wrapperhyrec.c index 9ddad6c..6f994d1 100644 --- a/src/pyhyrec/wrapperhyrec.c +++ b/src/pyhyrec/wrapperhyrec.c @@ -1,9 +1,10 @@ -/* Generated by Cython 3.0.8 */ +/* Generated by Cython 3.0.9 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ + "src/pyhyrec/src/energy_injection.h", "src/pyhyrec/src/history.h" ], "include_dirs": [ @@ -42,10 +43,10 @@ END: Cython Metadata */ #else #define __PYX_EXTRA_ABI_MODULE_NAME "" #endif -#define CYTHON_ABI "3_0_8" __PYX_EXTRA_ABI_MODULE_NAME +#define CYTHON_ABI "3_0_9" __PYX_EXTRA_ABI_MODULE_NAME #define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI #define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -#define CYTHON_HEX_VERSION 0x030008F0 +#define CYTHON_HEX_VERSION 0x030009F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof @@ -738,8 +739,13 @@ END: Cython Metadata */ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif #endif #if CYTHON_METH_FASTCALL #define __Pyx_METH_FASTCALL METH_FASTCALL @@ -1091,7 +1097,7 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) #endif -#if PY_VERSION_HEX >= 0x030d00A1 +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) #else static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { @@ -1178,7 +1184,7 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } @@ -1203,6 +1209,7 @@ static CYTHON_INLINE float __PYX_NAN() { #define __PYX_HAVE_API__pyhyrec__wrapperhyrec /* Early includes */ #include "src/history.h" +#include "src/energy_injection.h" #ifdef _OPENMP #include #endif /* _OPENMP */ @@ -1282,24 +1289,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u) -{ - const wchar_t *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#else -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) -{ - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#endif #define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) @@ -2173,6 +2163,7 @@ static const char __pyx_k_h[] = "h"; static const char __pyx_k_z[] = "z"; static const char __pyx_k_T0[] = "T0"; static const char __pyx_k_iz[] = "iz"; +static const char __pyx_k_nB[] = "nB"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_nz[] = "nz"; static const char __pyx_k_os[] = "os"; @@ -2181,7 +2172,7 @@ static const char __pyx_k_wa[] = "wa"; static const char __pyx_k_YHe[] = "YHe"; static const char __pyx_k__27[] = "/"; static const char __pyx_k__28[] = "*"; -static const char __pyx_k__38[] = "?"; +static const char __pyx_k__40[] = "?"; static const char __pyx_k_fsR[] = "fsR"; static const char __pyx_k_max[] = "max"; static const char __pyx_k_meR[] = "meR"; @@ -2201,6 +2192,7 @@ static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_pann[] = "pann"; static const char __pyx_k_path[] = "path"; static const char __pyx_k_spec[] = "__spec__"; +static const char __pyx_k_tdti[] = "tdti"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_zmax[] = "zmax"; static const char __pyx_k_zmin[] = "zmin"; @@ -2257,6 +2249,7 @@ static const char __pyx_k_pyhyrec_wrapperhyrec[] = "pyhyrec.wrapperhyrec"; static const char __pyx_k_init_INPUT_INJ_PARAMS[] = "init_INPUT_INJ_PARAMS"; static const char __pyx_k_init_INPUT_COSMOPARAMS[] = "init_INPUT_COSMOPARAMS"; static const char __pyx_k_src_pyhyrec_wrapperhyrec_pyx[] = "src/pyhyrec/wrapperhyrec.pyx"; +static const char __pyx_k_call_decay_rate_pmf_turbulences[] = "call_decay_rate_pmf_turbulences"; static const char __pyx_k_No_value_specified_for_struct_at[] = "No value specified for struct attribute 'h'"; static const char __pyx_k_No_value_specified_for_struct_at_2[] = "No value specified for struct attribute 'T0'"; static const char __pyx_k_No_value_specified_for_struct_at_3[] = "No value specified for struct attribute 'Omega_b'"; @@ -2288,6 +2281,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_warning_on_one_line(CYTHON_UNU static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED PyObject *__pyx_self, INPUT_COSMOPARAMS __pyx_v_cosmo_params, INPUT_INJ_PARAMS __pyx_v_inj_params, double __pyx_v_zmax, double __pyx_v_zmin, int __pyx_v_nz); /* proto */ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_pann, double __pyx_v_pann_halo, double __pyx_v_ann_z, double __pyx_v_ann_zmax, double __pyx_v_ann_zmin, double __pyx_v_ann_var, double __pyx_v_ann_z_halo, double __pyx_v_decay, int __pyx_v_on_the_spot, double __pyx_v_Mpbh, double __pyx_v_fpbh); /* proto */ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_h, double __pyx_v_T0, double __pyx_v_Omega_b, double __pyx_v_Omega_cb, double __pyx_v_Omega_k, double __pyx_v_w0, double __pyx_v_wa, double __pyx_v_Neff, double __pyx_v_Nmnu, double __pyx_v_mnu1, double __pyx_v_mnu2, double __pyx_v_mnu3, double __pyx_v_YHe, double __pyx_v_fsR, double __pyx_v_meR); /* proto */ +static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_8call_decay_rate_pmf_turbulences(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_z, double __pyx_v_tdti, double __pyx_v_nB); /* proto */ /* #### Code section: late_includes ### */ /* #### Code section: module_state ### */ typedef struct { @@ -2356,13 +2350,14 @@ typedef struct { PyObject *__pyx_n_s_YHe; PyObject *__pyx_kp_s__27; PyObject *__pyx_n_s__28; - PyObject *__pyx_n_s__38; + PyObject *__pyx_n_s__40; PyObject *__pyx_n_s_ann_var; PyObject *__pyx_n_s_ann_z; PyObject *__pyx_n_s_ann_z_halo; PyObject *__pyx_n_s_ann_zmax; PyObject *__pyx_n_s_ann_zmin; PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_call_decay_rate_pmf_turbulences; PyObject *__pyx_n_s_call_run_hyrec; PyObject *__pyx_n_s_category; PyObject *__pyx_n_s_cline_in_traceback; @@ -2401,6 +2396,7 @@ typedef struct { PyObject *__pyx_n_s_mnu1; PyObject *__pyx_n_s_mnu2; PyObject *__pyx_n_s_mnu3; + PyObject *__pyx_n_s_nB; PyObject *__pyx_n_s_name; PyObject *__pyx_n_s_np; PyObject *__pyx_n_s_numpy; @@ -2419,6 +2415,7 @@ typedef struct { PyObject *__pyx_n_s_split; PyObject *__pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx; PyObject *__pyx_n_s_str_table_location; + PyObject *__pyx_n_s_tdti; PyObject *__pyx_n_s_test; PyObject *__pyx_kp_s_utf_8; PyObject *__pyx_n_s_w0; @@ -2465,10 +2462,12 @@ typedef struct { PyObject *__pyx_tuple__32; PyObject *__pyx_tuple__34; PyObject *__pyx_tuple__36; + PyObject *__pyx_tuple__38; PyObject *__pyx_codeobj__30; PyObject *__pyx_codeobj__33; PyObject *__pyx_codeobj__35; PyObject *__pyx_codeobj__37; + PyObject *__pyx_codeobj__39; } __pyx_mstate; #if CYTHON_USE_MODULE_STATE @@ -2550,13 +2549,14 @@ static int __pyx_m_clear(PyObject *m) { Py_CLEAR(clear_module_state->__pyx_n_s_YHe); Py_CLEAR(clear_module_state->__pyx_kp_s__27); Py_CLEAR(clear_module_state->__pyx_n_s__28); - Py_CLEAR(clear_module_state->__pyx_n_s__38); + Py_CLEAR(clear_module_state->__pyx_n_s__40); Py_CLEAR(clear_module_state->__pyx_n_s_ann_var); Py_CLEAR(clear_module_state->__pyx_n_s_ann_z); Py_CLEAR(clear_module_state->__pyx_n_s_ann_z_halo); Py_CLEAR(clear_module_state->__pyx_n_s_ann_zmax); Py_CLEAR(clear_module_state->__pyx_n_s_ann_zmin); Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_call_decay_rate_pmf_turbulences); Py_CLEAR(clear_module_state->__pyx_n_s_call_run_hyrec); Py_CLEAR(clear_module_state->__pyx_n_s_category); Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); @@ -2595,6 +2595,7 @@ static int __pyx_m_clear(PyObject *m) { Py_CLEAR(clear_module_state->__pyx_n_s_mnu1); Py_CLEAR(clear_module_state->__pyx_n_s_mnu2); Py_CLEAR(clear_module_state->__pyx_n_s_mnu3); + Py_CLEAR(clear_module_state->__pyx_n_s_nB); Py_CLEAR(clear_module_state->__pyx_n_s_name); Py_CLEAR(clear_module_state->__pyx_n_s_np); Py_CLEAR(clear_module_state->__pyx_n_s_numpy); @@ -2613,6 +2614,7 @@ static int __pyx_m_clear(PyObject *m) { Py_CLEAR(clear_module_state->__pyx_n_s_split); Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx); Py_CLEAR(clear_module_state->__pyx_n_s_str_table_location); + Py_CLEAR(clear_module_state->__pyx_n_s_tdti); Py_CLEAR(clear_module_state->__pyx_n_s_test); Py_CLEAR(clear_module_state->__pyx_kp_s_utf_8); Py_CLEAR(clear_module_state->__pyx_n_s_w0); @@ -2659,10 +2661,12 @@ static int __pyx_m_clear(PyObject *m) { Py_CLEAR(clear_module_state->__pyx_tuple__32); Py_CLEAR(clear_module_state->__pyx_tuple__34); Py_CLEAR(clear_module_state->__pyx_tuple__36); + Py_CLEAR(clear_module_state->__pyx_tuple__38); Py_CLEAR(clear_module_state->__pyx_codeobj__30); Py_CLEAR(clear_module_state->__pyx_codeobj__33); Py_CLEAR(clear_module_state->__pyx_codeobj__35); Py_CLEAR(clear_module_state->__pyx_codeobj__37); + Py_CLEAR(clear_module_state->__pyx_codeobj__39); return 0; } #endif @@ -2722,13 +2726,14 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { Py_VISIT(traverse_module_state->__pyx_n_s_YHe); Py_VISIT(traverse_module_state->__pyx_kp_s__27); Py_VISIT(traverse_module_state->__pyx_n_s__28); - Py_VISIT(traverse_module_state->__pyx_n_s__38); + Py_VISIT(traverse_module_state->__pyx_n_s__40); Py_VISIT(traverse_module_state->__pyx_n_s_ann_var); Py_VISIT(traverse_module_state->__pyx_n_s_ann_z); Py_VISIT(traverse_module_state->__pyx_n_s_ann_z_halo); Py_VISIT(traverse_module_state->__pyx_n_s_ann_zmax); Py_VISIT(traverse_module_state->__pyx_n_s_ann_zmin); Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_call_decay_rate_pmf_turbulences); Py_VISIT(traverse_module_state->__pyx_n_s_call_run_hyrec); Py_VISIT(traverse_module_state->__pyx_n_s_category); Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); @@ -2767,6 +2772,7 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { Py_VISIT(traverse_module_state->__pyx_n_s_mnu1); Py_VISIT(traverse_module_state->__pyx_n_s_mnu2); Py_VISIT(traverse_module_state->__pyx_n_s_mnu3); + Py_VISIT(traverse_module_state->__pyx_n_s_nB); Py_VISIT(traverse_module_state->__pyx_n_s_name); Py_VISIT(traverse_module_state->__pyx_n_s_np); Py_VISIT(traverse_module_state->__pyx_n_s_numpy); @@ -2785,6 +2791,7 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { Py_VISIT(traverse_module_state->__pyx_n_s_split); Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx); Py_VISIT(traverse_module_state->__pyx_n_s_str_table_location); + Py_VISIT(traverse_module_state->__pyx_n_s_tdti); Py_VISIT(traverse_module_state->__pyx_n_s_test); Py_VISIT(traverse_module_state->__pyx_kp_s_utf_8); Py_VISIT(traverse_module_state->__pyx_n_s_w0); @@ -2831,10 +2838,12 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { Py_VISIT(traverse_module_state->__pyx_tuple__32); Py_VISIT(traverse_module_state->__pyx_tuple__34); Py_VISIT(traverse_module_state->__pyx_tuple__36); + Py_VISIT(traverse_module_state->__pyx_tuple__38); Py_VISIT(traverse_module_state->__pyx_codeobj__30); Py_VISIT(traverse_module_state->__pyx_codeobj__33); Py_VISIT(traverse_module_state->__pyx_codeobj__35); Py_VISIT(traverse_module_state->__pyx_codeobj__37); + Py_VISIT(traverse_module_state->__pyx_codeobj__39); return 0; } #endif @@ -2904,13 +2913,14 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { #define __pyx_n_s_YHe __pyx_mstate_global->__pyx_n_s_YHe #define __pyx_kp_s__27 __pyx_mstate_global->__pyx_kp_s__27 #define __pyx_n_s__28 __pyx_mstate_global->__pyx_n_s__28 -#define __pyx_n_s__38 __pyx_mstate_global->__pyx_n_s__38 +#define __pyx_n_s__40 __pyx_mstate_global->__pyx_n_s__40 #define __pyx_n_s_ann_var __pyx_mstate_global->__pyx_n_s_ann_var #define __pyx_n_s_ann_z __pyx_mstate_global->__pyx_n_s_ann_z #define __pyx_n_s_ann_z_halo __pyx_mstate_global->__pyx_n_s_ann_z_halo #define __pyx_n_s_ann_zmax __pyx_mstate_global->__pyx_n_s_ann_zmax #define __pyx_n_s_ann_zmin __pyx_mstate_global->__pyx_n_s_ann_zmin #define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_call_decay_rate_pmf_turbulences __pyx_mstate_global->__pyx_n_s_call_decay_rate_pmf_turbulences #define __pyx_n_s_call_run_hyrec __pyx_mstate_global->__pyx_n_s_call_run_hyrec #define __pyx_n_s_category __pyx_mstate_global->__pyx_n_s_category #define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback @@ -2949,6 +2959,7 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { #define __pyx_n_s_mnu1 __pyx_mstate_global->__pyx_n_s_mnu1 #define __pyx_n_s_mnu2 __pyx_mstate_global->__pyx_n_s_mnu2 #define __pyx_n_s_mnu3 __pyx_mstate_global->__pyx_n_s_mnu3 +#define __pyx_n_s_nB __pyx_mstate_global->__pyx_n_s_nB #define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name #define __pyx_n_s_np __pyx_mstate_global->__pyx_n_s_np #define __pyx_n_s_numpy __pyx_mstate_global->__pyx_n_s_numpy @@ -2967,6 +2978,7 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { #define __pyx_n_s_split __pyx_mstate_global->__pyx_n_s_split #define __pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx __pyx_mstate_global->__pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx #define __pyx_n_s_str_table_location __pyx_mstate_global->__pyx_n_s_str_table_location +#define __pyx_n_s_tdti __pyx_mstate_global->__pyx_n_s_tdti #define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test #define __pyx_kp_s_utf_8 __pyx_mstate_global->__pyx_kp_s_utf_8 #define __pyx_n_s_w0 __pyx_mstate_global->__pyx_n_s_w0 @@ -3013,10 +3025,12 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { #define __pyx_tuple__32 __pyx_mstate_global->__pyx_tuple__32 #define __pyx_tuple__34 __pyx_mstate_global->__pyx_tuple__34 #define __pyx_tuple__36 __pyx_mstate_global->__pyx_tuple__36 +#define __pyx_tuple__38 __pyx_mstate_global->__pyx_tuple__38 #define __pyx_codeobj__30 __pyx_mstate_global->__pyx_codeobj__30 #define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 #define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35 #define __pyx_codeobj__37 __pyx_mstate_global->__pyx_codeobj__37 +#define __pyx_codeobj__39 __pyx_mstate_global->__pyx_codeobj__39 /* #### Code section: module_code ### */ /* "FromPyStructUtility":12 @@ -6118,7 +6132,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_warning_on_one_line(CYTHON_UNU return __pyx_r; } -/* "pyhyrec/wrapperhyrec.pyx":64 +/* "pyhyrec/wrapperhyrec.pyx":63 * Array with size `nz` of the inter-galactic medium temperature [in K] * """ * def call_run_hyrec(INPUT_COSMOPARAMS cosmo_params, INPUT_INJ_PARAMS inj_params, double zmax = 8000.0, double zmin = 0.0, int nz = 8000): # <<<<<<<<<<<<<< @@ -6191,7 +6205,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: @@ -6199,35 +6213,35 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("call_run_hyrec", 0, 2, 5, 1); __PYX_ERR(0, 64, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("call_run_hyrec", 0, 2, 5, 1); __PYX_ERR(0, 63, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_zmax); if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_zmin); if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nz); if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "call_run_hyrec") < 0)) __PYX_ERR(0, 64, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "call_run_hyrec") < 0)) __PYX_ERR(0, 63, __pyx_L3_error) } } else { switch (__pyx_nargs) { @@ -6243,27 +6257,27 @@ PyObject *__pyx_args, PyObject *__pyx_kwds default: goto __pyx_L5_argtuple_error; } } - __pyx_v_cosmo_params = __pyx_convert__from_py_INPUT_COSMOPARAMS(values[0]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) - __pyx_v_inj_params = __pyx_convert__from_py_INPUT_INJ_PARAMS(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + __pyx_v_cosmo_params = __pyx_convert__from_py_INPUT_COSMOPARAMS(values[0]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) + __pyx_v_inj_params = __pyx_convert__from_py_INPUT_INJ_PARAMS(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) if (values[2]) { - __pyx_v_zmax = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_zmax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + __pyx_v_zmax = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_zmax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) } else { __pyx_v_zmax = ((double)((double)8000.0)); } if (values[3]) { - __pyx_v_zmin = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_zmin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + __pyx_v_zmin = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_zmin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) } else { __pyx_v_zmin = ((double)((double)0.0)); } if (values[4]) { - __pyx_v_nz = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_nz == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + __pyx_v_nz = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_nz == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) } else { __pyx_v_nz = ((int)((int)0x1F40)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("call_run_hyrec", 0, 2, 5, __pyx_nargs); __PYX_ERR(0, 64, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("call_run_hyrec", 0, 2, 5, __pyx_nargs); __PYX_ERR(0, 63, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -6320,38 +6334,38 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED int __pyx_clineno = 0; __Pyx_RefNannySetupContext("call_run_hyrec", 1); - /* "pyhyrec/wrapperhyrec.pyx":66 + /* "pyhyrec/wrapperhyrec.pyx":65 * def call_run_hyrec(INPUT_COSMOPARAMS cosmo_params, INPUT_INJ_PARAMS inj_params, double zmax = 8000.0, double zmin = 0.0, int nz = 8000): * * str_table_location = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'data/') # <<<<<<<<<<<<<< * cstr_table_location = str_table_location.encode('utf-8') * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_join); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_join); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_os); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_os); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_path); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 66, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_path); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_dirname); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 66, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_dirname); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_os); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_os); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_path); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 66, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_path); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_realpath); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 66, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_realpath); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_file_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_file_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; @@ -6372,7 +6386,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 66, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -6395,7 +6409,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } @@ -6418,21 +6432,21 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_9, 2+__pyx_t_9); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 66, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_v_str_table_location = __pyx_t_1; __pyx_t_1 = 0; - /* "pyhyrec/wrapperhyrec.pyx":67 + /* "pyhyrec/wrapperhyrec.pyx":66 * * str_table_location = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'data/') * cstr_table_location = str_table_location.encode('utf-8') # <<<<<<<<<<<<<< * * # Calling the Hyrec C function returning a pointer of type HYREC_DATA */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_str_table_location, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 67, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_str_table_location, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_9 = 0; @@ -6452,24 +6466,24 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_kp_s_utf_8}; __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_v_cstr_table_location = __pyx_t_1; __pyx_t_1 = 0; - /* "pyhyrec/wrapperhyrec.pyx":70 + /* "pyhyrec/wrapperhyrec.pyx":69 * * # Calling the Hyrec C function returning a pointer of type HYREC_DATA * cdef HYREC_DATA * data = run_hyrec(cosmo_params, inj_params, zmax, zmin, cstr_table_location) # <<<<<<<<<<<<<< * * ## If something went wrong we print the error message */ - __pyx_t_10 = __Pyx_PyObject_AsWritableString(__pyx_v_cstr_table_location); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 70, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_AsWritableString(__pyx_v_cstr_table_location); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 69, __pyx_L1_error) __pyx_v_data = run_hyrec(__pyx_v_cosmo_params, __pyx_v_inj_params, __pyx_v_zmax, __pyx_v_zmin, __pyx_t_10); - /* "pyhyrec/wrapperhyrec.pyx":73 + /* "pyhyrec/wrapperhyrec.pyx":72 * * ## If something went wrong we print the error message * if data.error == 1 : # <<<<<<<<<<<<<< @@ -6479,7 +6493,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __pyx_t_11 = (__pyx_v_data->error == 1); if (__pyx_t_11) { - /* "pyhyrec/wrapperhyrec.pyx":74 + /* "pyhyrec/wrapperhyrec.pyx":73 * ## If something went wrong we print the error message * if data.error == 1 : * print(str(data.error_message.decode('utf-8'))) # <<<<<<<<<<<<<< @@ -6487,18 +6501,18 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED * # Define numpy arrays to store the data */ __pyx_t_10 = __pyx_v_data->error_message; - __pyx_t_12 = __Pyx_ssize_strlen(__pyx_t_10); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(0, 74, __pyx_L1_error) - __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_10, 0, __pyx_t_12, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) + __pyx_t_12 = __Pyx_ssize_strlen(__pyx_t_10); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(0, 73, __pyx_L1_error) + __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_10, 0, __pyx_t_12, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Str(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Str(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "pyhyrec/wrapperhyrec.pyx":73 + /* "pyhyrec/wrapperhyrec.pyx":72 * * ## If something went wrong we print the error message * if data.error == 1 : # <<<<<<<<<<<<<< @@ -6507,32 +6521,32 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED */ } - /* "pyhyrec/wrapperhyrec.pyx":77 + /* "pyhyrec/wrapperhyrec.pyx":76 * * # Define numpy arrays to store the data * z_array = np.linspace(np.max([zmin, 1.0]), zmax, nz) # <<<<<<<<<<<<<< * xe_array = np.zeros(nz) * Tm_array = np.zeros(nz) */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_linspace); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_linspace); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_zmin); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_zmin); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_4)) __PYX_ERR(0, 77, __pyx_L1_error); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_4)) __PYX_ERR(0, 76, __pyx_L1_error); __Pyx_INCREF(__pyx_float_1_0); __Pyx_GIVEREF(__pyx_float_1_0); - if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_float_1_0)) __PYX_ERR(0, 77, __pyx_L1_error); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_float_1_0)) __PYX_ERR(0, 76, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_4 = NULL; __pyx_t_9 = 0; @@ -6553,13 +6567,13 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_zmax); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_zmax); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_nz); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_nz); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = NULL; __pyx_t_9 = 0; @@ -6582,26 +6596,26 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_z_array = __pyx_t_1; __pyx_t_1 = 0; - /* "pyhyrec/wrapperhyrec.pyx":78 + /* "pyhyrec/wrapperhyrec.pyx":77 * # Define numpy arrays to store the data * z_array = np.linspace(np.max([zmin, 1.0]), zmax, nz) * xe_array = np.zeros(nz) # <<<<<<<<<<<<<< * Tm_array = np.zeros(nz) * */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 78, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nz); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nz); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; __pyx_t_9 = 0; @@ -6622,26 +6636,26 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_v_xe_array = __pyx_t_1; __pyx_t_1 = 0; - /* "pyhyrec/wrapperhyrec.pyx":79 + /* "pyhyrec/wrapperhyrec.pyx":78 * z_array = np.linspace(np.max([zmin, 1.0]), zmax, nz) * xe_array = np.zeros(nz) * Tm_array = np.zeros(nz) # <<<<<<<<<<<<<< * * # Transfering the data from the C code to the numpy arrays */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_nz); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_nz); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = NULL; __pyx_t_9 = 0; @@ -6662,14 +6676,14 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_v_Tm_array = __pyx_t_1; __pyx_t_1 = 0; - /* "pyhyrec/wrapperhyrec.pyx":82 + /* "pyhyrec/wrapperhyrec.pyx":81 * * # Transfering the data from the C code to the numpy arrays * for iz, z in enumerate(z_array): # <<<<<<<<<<<<<< @@ -6683,9 +6697,9 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __pyx_t_12 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_12 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_z_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_12 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_z_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_13 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 81, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_13)) { @@ -6693,28 +6707,28 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 82, __pyx_L1_error) + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 81, __pyx_L1_error) #endif if (__pyx_t_12 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_t_12++; if (unlikely((0 < 0))) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_t_12++; if (unlikely((0 < 0))) __PYX_ERR(0, 81, __pyx_L1_error) #else - __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 82, __pyx_L1_error) + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 81, __pyx_L1_error) #endif if (__pyx_t_12 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_t_12++; if (unlikely((0 < 0))) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_t_12++; if (unlikely((0 < 0))) __PYX_ERR(0, 81, __pyx_L1_error) #else - __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif } @@ -6724,7 +6738,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 82, __pyx_L1_error) + else __PYX_ERR(0, 81, __pyx_L1_error) } break; } @@ -6734,39 +6748,39 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __pyx_t_6 = 0; __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_iz, __pyx_t_1); - __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_6; __pyx_t_6 = 0; - /* "pyhyrec/wrapperhyrec.pyx":83 + /* "pyhyrec/wrapperhyrec.pyx":82 * # Transfering the data from the C code to the numpy arrays * for iz, z in enumerate(z_array): * xe_array[iz] = hyrec_xe(z, data) # <<<<<<<<<<<<<< * Tm_array[iz] = hyrec_Tm(z, data) * */ - __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_z); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L1_error) - __pyx_t_6 = PyFloat_FromDouble(hyrec_xe(__pyx_t_14, __pyx_v_data)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 83, __pyx_L1_error) + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_z); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble(hyrec_xe(__pyx_t_14, __pyx_v_data)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (unlikely((PyObject_SetItem(__pyx_v_xe_array, __pyx_v_iz, __pyx_t_6) < 0))) __PYX_ERR(0, 83, __pyx_L1_error) + if (unlikely((PyObject_SetItem(__pyx_v_xe_array, __pyx_v_iz, __pyx_t_6) < 0))) __PYX_ERR(0, 82, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "pyhyrec/wrapperhyrec.pyx":84 + /* "pyhyrec/wrapperhyrec.pyx":83 * for iz, z in enumerate(z_array): * xe_array[iz] = hyrec_xe(z, data) * Tm_array[iz] = hyrec_Tm(z, data) # <<<<<<<<<<<<<< * * # Free the memory at the end */ - __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_z); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L1_error) - __pyx_t_6 = PyFloat_FromDouble(hyrec_Tm(__pyx_t_14, __pyx_v_data)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 84, __pyx_L1_error) + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_z); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble(hyrec_Tm(__pyx_t_14, __pyx_v_data)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 83, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (unlikely((PyObject_SetItem(__pyx_v_Tm_array, __pyx_v_iz, __pyx_t_6) < 0))) __PYX_ERR(0, 84, __pyx_L1_error) + if (unlikely((PyObject_SetItem(__pyx_v_Tm_array, __pyx_v_iz, __pyx_t_6) < 0))) __PYX_ERR(0, 83, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "pyhyrec/wrapperhyrec.pyx":82 + /* "pyhyrec/wrapperhyrec.pyx":81 * * # Transfering the data from the C code to the numpy arrays * for iz, z in enumerate(z_array): # <<<<<<<<<<<<<< @@ -6777,7 +6791,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "pyhyrec/wrapperhyrec.pyx":87 + /* "pyhyrec/wrapperhyrec.pyx":86 * * # Free the memory at the end * hyrec_free(data) # <<<<<<<<<<<<<< @@ -6786,7 +6800,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED */ hyrec_free(__pyx_v_data); - /* "pyhyrec/wrapperhyrec.pyx":89 + /* "pyhyrec/wrapperhyrec.pyx":88 * hyrec_free(data) * * return z_array, xe_array, Tm_array # <<<<<<<<<<<<<< @@ -6794,22 +6808,22 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_z_array); __Pyx_GIVEREF(__pyx_v_z_array); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_z_array)) __PYX_ERR(0, 89, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_z_array)) __PYX_ERR(0, 88, __pyx_L1_error); __Pyx_INCREF(__pyx_v_xe_array); __Pyx_GIVEREF(__pyx_v_xe_array); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_xe_array)) __PYX_ERR(0, 89, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_xe_array)) __PYX_ERR(0, 88, __pyx_L1_error); __Pyx_INCREF(__pyx_v_Tm_array); __Pyx_GIVEREF(__pyx_v_Tm_array); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_Tm_array)) __PYX_ERR(0, 89, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_Tm_array)) __PYX_ERR(0, 88, __pyx_L1_error); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "pyhyrec/wrapperhyrec.pyx":64 + /* "pyhyrec/wrapperhyrec.pyx":63 * Array with size `nz` of the inter-galactic medium temperature [in K] * """ * def call_run_hyrec(INPUT_COSMOPARAMS cosmo_params, INPUT_INJ_PARAMS inj_params, double zmax = 8000.0, double zmin = 0.0, int nz = 8000): # <<<<<<<<<<<<<< @@ -6842,7 +6856,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_2call_run_hyrec(CYTHON_UNUSED return __pyx_r; } -/* "pyhyrec/wrapperhyrec.pyx":93 +/* "pyhyrec/wrapperhyrec.pyx":92 * * * def init_INPUT_INJ_PARAMS(double pann, double pann_halo, # <<<<<<<<<<<<<< @@ -6933,7 +6947,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: @@ -6941,9 +6955,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 1); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 1); __PYX_ERR(0, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -6951,9 +6965,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 2); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 2); __PYX_ERR(0, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: @@ -6961,9 +6975,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 3); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 3); __PYX_ERR(0, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: @@ -6971,9 +6985,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 4); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 4); __PYX_ERR(0, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: @@ -6981,9 +6995,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[5]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 5); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 5); __PYX_ERR(0, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: @@ -6991,9 +7005,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[6]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 6); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 6); __PYX_ERR(0, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: @@ -7001,9 +7015,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[7]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 7); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 7); __PYX_ERR(0, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 8: @@ -7011,9 +7025,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[8]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 8); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 8); __PYX_ERR(0, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 9: @@ -7021,9 +7035,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[9]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 9); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 9); __PYX_ERR(0, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 10: @@ -7031,14 +7045,14 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[10]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 10); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, 10); __PYX_ERR(0, 92, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "init_INPUT_INJ_PARAMS") < 0)) __PYX_ERR(0, 93, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "init_INPUT_INJ_PARAMS") < 0)) __PYX_ERR(0, 92, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 11)) { goto __pyx_L5_argtuple_error; @@ -7055,21 +7069,21 @@ PyObject *__pyx_args, PyObject *__pyx_kwds values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); } - __pyx_v_pann = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_pann == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) - __pyx_v_pann_halo = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_pann_halo == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) - __pyx_v_ann_z = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ann_z == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L3_error) - __pyx_v_ann_zmax = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ann_zmax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L3_error) - __pyx_v_ann_zmin = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_ann_zmin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L3_error) - __pyx_v_ann_var = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_ann_var == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L3_error) - __pyx_v_ann_z_halo = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_ann_z_halo == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 95, __pyx_L3_error) - __pyx_v_decay = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_decay == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 95, __pyx_L3_error) - __pyx_v_on_the_spot = __Pyx_PyInt_As_int(values[8]); if (unlikely((__pyx_v_on_the_spot == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 95, __pyx_L3_error) - __pyx_v_Mpbh = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_Mpbh == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L3_error) - __pyx_v_fpbh = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_fpbh == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L3_error) + __pyx_v_pann = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_pann == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) + __pyx_v_pann_halo = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_pann_halo == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L3_error) + __pyx_v_ann_z = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ann_z == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + __pyx_v_ann_zmax = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ann_zmax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + __pyx_v_ann_zmin = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_ann_zmin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + __pyx_v_ann_var = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_ann_var == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L3_error) + __pyx_v_ann_z_halo = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_ann_z_halo == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L3_error) + __pyx_v_decay = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_decay == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L3_error) + __pyx_v_on_the_spot = __Pyx_PyInt_As_int(values[8]); if (unlikely((__pyx_v_on_the_spot == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L3_error) + __pyx_v_Mpbh = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_Mpbh == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 95, __pyx_L3_error) + __pyx_v_fpbh = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_fpbh == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 95, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, __pyx_nargs); __PYX_ERR(0, 93, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_INJ_PARAMS", 1, 11, 11, __pyx_nargs); __PYX_ERR(0, 92, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -7106,7 +7120,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("init_INPUT_INJ_PARAMS", 1); - /* "pyhyrec/wrapperhyrec.pyx":100 + /* "pyhyrec/wrapperhyrec.pyx":99 * cdef INPUT_INJ_PARAMS inj_params * * inj_params.pann = pann # <<<<<<<<<<<<<< @@ -7115,7 +7129,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ */ __pyx_v_inj_params.pann = __pyx_v_pann; - /* "pyhyrec/wrapperhyrec.pyx":101 + /* "pyhyrec/wrapperhyrec.pyx":100 * * inj_params.pann = pann * inj_params.pann_halo = pann_halo # <<<<<<<<<<<<<< @@ -7124,7 +7138,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ */ __pyx_v_inj_params.pann_halo = __pyx_v_pann_halo; - /* "pyhyrec/wrapperhyrec.pyx":102 + /* "pyhyrec/wrapperhyrec.pyx":101 * inj_params.pann = pann * inj_params.pann_halo = pann_halo * inj_params.ann_z = ann_z # <<<<<<<<<<<<<< @@ -7133,7 +7147,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ */ __pyx_v_inj_params.ann_z = __pyx_v_ann_z; - /* "pyhyrec/wrapperhyrec.pyx":103 + /* "pyhyrec/wrapperhyrec.pyx":102 * inj_params.pann_halo = pann_halo * inj_params.ann_z = ann_z * inj_params.ann_zmax = ann_zmax # <<<<<<<<<<<<<< @@ -7142,7 +7156,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ */ __pyx_v_inj_params.ann_zmax = __pyx_v_ann_zmax; - /* "pyhyrec/wrapperhyrec.pyx":104 + /* "pyhyrec/wrapperhyrec.pyx":103 * inj_params.ann_z = ann_z * inj_params.ann_zmax = ann_zmax * inj_params.ann_zmin = ann_zmin # <<<<<<<<<<<<<< @@ -7151,7 +7165,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ */ __pyx_v_inj_params.ann_zmin = __pyx_v_ann_zmin; - /* "pyhyrec/wrapperhyrec.pyx":105 + /* "pyhyrec/wrapperhyrec.pyx":104 * inj_params.ann_zmax = ann_zmax * inj_params.ann_zmin = ann_zmin * inj_params.ann_var = ann_var # <<<<<<<<<<<<<< @@ -7160,7 +7174,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ */ __pyx_v_inj_params.ann_var = __pyx_v_ann_var; - /* "pyhyrec/wrapperhyrec.pyx":106 + /* "pyhyrec/wrapperhyrec.pyx":105 * inj_params.ann_zmin = ann_zmin * inj_params.ann_var = ann_var * inj_params.ann_z_halo = ann_z_halo # <<<<<<<<<<<<<< @@ -7169,7 +7183,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ */ __pyx_v_inj_params.ann_z_halo = __pyx_v_ann_z_halo; - /* "pyhyrec/wrapperhyrec.pyx":107 + /* "pyhyrec/wrapperhyrec.pyx":106 * inj_params.ann_var = ann_var * inj_params.ann_z_halo = ann_z_halo * inj_params.decay = decay # <<<<<<<<<<<<<< @@ -7178,48 +7192,48 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ */ __pyx_v_inj_params.decay = __pyx_v_decay; - /* "pyhyrec/wrapperhyrec.pyx":108 + /* "pyhyrec/wrapperhyrec.pyx":107 * inj_params.ann_z_halo = ann_z_halo * inj_params.decay = decay * inj_params.on_the_spot = on_the_spot # <<<<<<<<<<<<<< * inj_params.Mpbh = Mpbh - * inj_params.fpbh = fpbh + * inj_params.fpbh = fpbh */ __pyx_v_inj_params.on_the_spot = __pyx_v_on_the_spot; - /* "pyhyrec/wrapperhyrec.pyx":109 + /* "pyhyrec/wrapperhyrec.pyx":108 * inj_params.decay = decay * inj_params.on_the_spot = on_the_spot * inj_params.Mpbh = Mpbh # <<<<<<<<<<<<<< - * inj_params.fpbh = fpbh + * inj_params.fpbh = fpbh * */ __pyx_v_inj_params.Mpbh = __pyx_v_Mpbh; - /* "pyhyrec/wrapperhyrec.pyx":110 + /* "pyhyrec/wrapperhyrec.pyx":109 * inj_params.on_the_spot = on_the_spot * inj_params.Mpbh = Mpbh - * inj_params.fpbh = fpbh # <<<<<<<<<<<<<< + * inj_params.fpbh = fpbh # <<<<<<<<<<<<<< * * return inj_params */ __pyx_v_inj_params.fpbh = __pyx_v_fpbh; - /* "pyhyrec/wrapperhyrec.pyx":112 - * inj_params.fpbh = fpbh + /* "pyhyrec/wrapperhyrec.pyx":111 + * inj_params.fpbh = fpbh * * return inj_params # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert__to_py_INPUT_INJ_PARAMS(__pyx_v_inj_params); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_1 = __pyx_convert__to_py_INPUT_INJ_PARAMS(__pyx_v_inj_params); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "pyhyrec/wrapperhyrec.pyx":93 + /* "pyhyrec/wrapperhyrec.pyx":92 * * * def init_INPUT_INJ_PARAMS(double pann, double pann_halo, # <<<<<<<<<<<<<< @@ -7238,7 +7252,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_4init_INPUT_INJ_PARAMS(CYTHON_ return __pyx_r; } -/* "pyhyrec/wrapperhyrec.pyx":115 +/* "pyhyrec/wrapperhyrec.pyx":114 * * * def init_INPUT_COSMOPARAMS(double h, double T0, # <<<<<<<<<<<<<< @@ -7341,7 +7355,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: @@ -7349,9 +7363,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 1); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 1); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -7359,9 +7373,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 2); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 2); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: @@ -7369,9 +7383,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 3); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 3); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: @@ -7379,9 +7393,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 4); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 4); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: @@ -7389,9 +7403,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[5]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 5); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 5); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: @@ -7399,9 +7413,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[6]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 6); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 6); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: @@ -7409,9 +7423,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[7]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 7); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 7); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 8: @@ -7419,9 +7433,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[8]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 8); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 8); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 9: @@ -7429,9 +7443,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[9]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 9); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 9); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 10: @@ -7439,9 +7453,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[10]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 10); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 10); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 11: @@ -7449,9 +7463,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[11]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 11); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 11); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 12: @@ -7459,9 +7473,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[12]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 12); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 12); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 13: @@ -7469,9 +7483,9 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[13]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 13); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 13); __PYX_ERR(0, 114, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 14: @@ -7479,14 +7493,14 @@ PyObject *__pyx_args, PyObject *__pyx_kwds (void)__Pyx_Arg_NewRef_FASTCALL(values[14]); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) else { - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 14); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, 14); __PYX_ERR(0, 114, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "init_INPUT_COSMOPARAMS") < 0)) __PYX_ERR(0, 115, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "init_INPUT_COSMOPARAMS") < 0)) __PYX_ERR(0, 114, __pyx_L3_error) } } else if (unlikely(__pyx_nargs != 15)) { goto __pyx_L5_argtuple_error; @@ -7507,25 +7521,25 @@ PyObject *__pyx_args, PyObject *__pyx_kwds values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); values[14] = __Pyx_Arg_FASTCALL(__pyx_args, 14); } - __pyx_v_h = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_h == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) - __pyx_v_T0 = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_T0 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) - __pyx_v_Omega_b = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_Omega_b == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error) - __pyx_v_Omega_cb = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_Omega_cb == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error) - __pyx_v_Omega_k = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_Omega_k == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error) - __pyx_v_w0 = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_w0 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) - __pyx_v_wa = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_wa == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) - __pyx_v_Neff = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_Neff == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) - __pyx_v_Nmnu = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_Nmnu == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) - __pyx_v_mnu1 = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_mnu1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L3_error) - __pyx_v_mnu2 = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_mnu2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L3_error) - __pyx_v_mnu3 = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_mnu3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L3_error) - __pyx_v_YHe = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_YHe == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error) - __pyx_v_fsR = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_fsR == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error) - __pyx_v_meR = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_meR == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error) + __pyx_v_h = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_h == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) + __pyx_v_T0 = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_T0 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L3_error) + __pyx_v_Omega_b = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_Omega_b == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + __pyx_v_Omega_cb = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_Omega_cb == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + __pyx_v_Omega_k = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_Omega_k == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error) + __pyx_v_w0 = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_w0 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error) + __pyx_v_wa = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_wa == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error) + __pyx_v_Neff = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_Neff == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error) + __pyx_v_Nmnu = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_Nmnu == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error) + __pyx_v_mnu1 = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_mnu1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) + __pyx_v_mnu2 = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_mnu2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) + __pyx_v_mnu3 = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_mnu3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L3_error) + __pyx_v_YHe = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_YHe == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L3_error) + __pyx_v_fsR = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_fsR == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L3_error) + __pyx_v_meR = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_meR == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, __pyx_nargs); __PYX_ERR(0, 115, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("init_INPUT_COSMOPARAMS", 1, 15, 15, __pyx_nargs); __PYX_ERR(0, 114, __pyx_L3_error) __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; @@ -7562,7 +7576,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON int __pyx_clineno = 0; __Pyx_RefNannySetupContext("init_INPUT_COSMOPARAMS", 1); - /* "pyhyrec/wrapperhyrec.pyx":123 + /* "pyhyrec/wrapperhyrec.pyx":122 * cdef INPUT_COSMOPARAMS cosmo * * cosmo.h = h # <<<<<<<<<<<<<< @@ -7571,7 +7585,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.h = __pyx_v_h; - /* "pyhyrec/wrapperhyrec.pyx":124 + /* "pyhyrec/wrapperhyrec.pyx":123 * * cosmo.h = h * cosmo.T0 = T0 # <<<<<<<<<<<<<< @@ -7580,7 +7594,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.T0 = __pyx_v_T0; - /* "pyhyrec/wrapperhyrec.pyx":125 + /* "pyhyrec/wrapperhyrec.pyx":124 * cosmo.h = h * cosmo.T0 = T0 * cosmo.Omega_b = Omega_b # <<<<<<<<<<<<<< @@ -7589,7 +7603,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.Omega_b = __pyx_v_Omega_b; - /* "pyhyrec/wrapperhyrec.pyx":126 + /* "pyhyrec/wrapperhyrec.pyx":125 * cosmo.T0 = T0 * cosmo.Omega_b = Omega_b * cosmo.Omega_cb = Omega_cb # <<<<<<<<<<<<<< @@ -7598,7 +7612,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.Omega_cb = __pyx_v_Omega_cb; - /* "pyhyrec/wrapperhyrec.pyx":127 + /* "pyhyrec/wrapperhyrec.pyx":126 * cosmo.Omega_b = Omega_b * cosmo.Omega_cb = Omega_cb * cosmo.Omega_k = Omega_k # <<<<<<<<<<<<<< @@ -7607,7 +7621,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.Omega_k = __pyx_v_Omega_k; - /* "pyhyrec/wrapperhyrec.pyx":128 + /* "pyhyrec/wrapperhyrec.pyx":127 * cosmo.Omega_cb = Omega_cb * cosmo.Omega_k = Omega_k * cosmo.w0 = w0 # <<<<<<<<<<<<<< @@ -7616,7 +7630,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.w0 = __pyx_v_w0; - /* "pyhyrec/wrapperhyrec.pyx":129 + /* "pyhyrec/wrapperhyrec.pyx":128 * cosmo.Omega_k = Omega_k * cosmo.w0 = w0 * cosmo.wa = wa # <<<<<<<<<<<<<< @@ -7625,7 +7639,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.wa = __pyx_v_wa; - /* "pyhyrec/wrapperhyrec.pyx":130 + /* "pyhyrec/wrapperhyrec.pyx":129 * cosmo.w0 = w0 * cosmo.wa = wa * cosmo.Neff = Neff # <<<<<<<<<<<<<< @@ -7634,7 +7648,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.Neff = __pyx_v_Neff; - /* "pyhyrec/wrapperhyrec.pyx":131 + /* "pyhyrec/wrapperhyrec.pyx":130 * cosmo.wa = wa * cosmo.Neff = Neff * cosmo.Nmnu = Nmnu # <<<<<<<<<<<<<< @@ -7643,7 +7657,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.Nmnu = __pyx_v_Nmnu; - /* "pyhyrec/wrapperhyrec.pyx":132 + /* "pyhyrec/wrapperhyrec.pyx":131 * cosmo.Neff = Neff * cosmo.Nmnu = Nmnu * cosmo.mnu1 = mnu1 # <<<<<<<<<<<<<< @@ -7652,7 +7666,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.mnu1 = __pyx_v_mnu1; - /* "pyhyrec/wrapperhyrec.pyx":133 + /* "pyhyrec/wrapperhyrec.pyx":132 * cosmo.Nmnu = Nmnu * cosmo.mnu1 = mnu1 * cosmo.mnu2 = mnu2 # <<<<<<<<<<<<<< @@ -7661,7 +7675,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.mnu2 = __pyx_v_mnu2; - /* "pyhyrec/wrapperhyrec.pyx":134 + /* "pyhyrec/wrapperhyrec.pyx":133 * cosmo.mnu1 = mnu1 * cosmo.mnu2 = mnu2 * cosmo.mnu3 = mnu3 # <<<<<<<<<<<<<< @@ -7670,7 +7684,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.mnu3 = __pyx_v_mnu3; - /* "pyhyrec/wrapperhyrec.pyx":135 + /* "pyhyrec/wrapperhyrec.pyx":134 * cosmo.mnu2 = mnu2 * cosmo.mnu3 = mnu3 * cosmo.YHe = YHe # <<<<<<<<<<<<<< @@ -7679,7 +7693,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.YHe = __pyx_v_YHe; - /* "pyhyrec/wrapperhyrec.pyx":136 + /* "pyhyrec/wrapperhyrec.pyx":135 * cosmo.mnu3 = mnu3 * cosmo.YHe = YHe * cosmo.fsR = fsR # <<<<<<<<<<<<<< @@ -7688,7 +7702,7 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.fsR = __pyx_v_fsR; - /* "pyhyrec/wrapperhyrec.pyx":137 + /* "pyhyrec/wrapperhyrec.pyx":136 * cosmo.YHe = YHe * cosmo.fsR = fsR * cosmo.meR = meR # <<<<<<<<<<<<<< @@ -7697,19 +7711,21 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON */ __pyx_v_cosmo.meR = __pyx_v_meR; - /* "pyhyrec/wrapperhyrec.pyx":139 + /* "pyhyrec/wrapperhyrec.pyx":138 * cosmo.meR = meR * * return cosmo; # <<<<<<<<<<<<<< + * + * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert__to_py_INPUT_COSMOPARAMS(__pyx_v_cosmo); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __pyx_t_1 = __pyx_convert__to_py_INPUT_COSMOPARAMS(__pyx_v_cosmo); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "pyhyrec/wrapperhyrec.pyx":115 + /* "pyhyrec/wrapperhyrec.pyx":114 * * * def init_INPUT_COSMOPARAMS(double h, double T0, # <<<<<<<<<<<<<< @@ -7728,6 +7744,178 @@ static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_6init_INPUT_COSMOPARAMS(CYTHON return __pyx_r; } +/* "pyhyrec/wrapperhyrec.pyx":147 + * + * + * def call_decay_rate_pmf_turbulences(double z, double tdti, double nB): # <<<<<<<<<<<<<< + * return decay_rate_pmf_turbulences(z, tdti, nB) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pyhyrec_12wrapperhyrec_9call_decay_rate_pmf_turbulences(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pyhyrec_12wrapperhyrec_9call_decay_rate_pmf_turbulences = {"call_decay_rate_pmf_turbulences", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pyhyrec_12wrapperhyrec_9call_decay_rate_pmf_turbulences, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pyhyrec_12wrapperhyrec_9call_decay_rate_pmf_turbulences(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + double __pyx_v_z; + double __pyx_v_tdti; + double __pyx_v_nB; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("call_decay_rate_pmf_turbulences (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_z,&__pyx_n_s_tdti,&__pyx_n_s_nB,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_z)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_tdti)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("call_decay_rate_pmf_turbulences", 1, 3, 3, 1); __PYX_ERR(0, 147, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nB)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("call_decay_rate_pmf_turbulences", 1, 3, 3, 2); __PYX_ERR(0, 147, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "call_decay_rate_pmf_turbulences") < 0)) __PYX_ERR(0, 147, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_z = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_z == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L3_error) + __pyx_v_tdti = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_tdti == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L3_error) + __pyx_v_nB = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nB == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("call_decay_rate_pmf_turbulences", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 147, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyhyrec.wrapperhyrec.call_decay_rate_pmf_turbulences", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pyhyrec_12wrapperhyrec_8call_decay_rate_pmf_turbulences(__pyx_self, __pyx_v_z, __pyx_v_tdti, __pyx_v_nB); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pyhyrec_12wrapperhyrec_8call_decay_rate_pmf_turbulences(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_z, double __pyx_v_tdti, double __pyx_v_nB) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("call_decay_rate_pmf_turbulences", 1); + + /* "pyhyrec/wrapperhyrec.pyx":148 + * + * def call_decay_rate_pmf_turbulences(double z, double tdti, double nB): + * return decay_rate_pmf_turbulences(z, tdti, nB) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(decay_rate_pmf_turbulences(__pyx_v_z, __pyx_v_tdti, __pyx_v_nB)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pyhyrec/wrapperhyrec.pyx":147 + * + * + * def call_decay_rate_pmf_turbulences(double z, double tdti, double nB): # <<<<<<<<<<<<<< + * return decay_rate_pmf_turbulences(z, tdti, nB) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyhyrec.wrapperhyrec.call_decay_rate_pmf_turbulences", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; @@ -7783,13 +7971,14 @@ static int __Pyx_CreateStringTabAndInitStrings(void) { {&__pyx_n_s_YHe, __pyx_k_YHe, sizeof(__pyx_k_YHe), 0, 0, 1, 1}, {&__pyx_kp_s__27, __pyx_k__27, sizeof(__pyx_k__27), 0, 0, 1, 0}, {&__pyx_n_s__28, __pyx_k__28, sizeof(__pyx_k__28), 0, 0, 1, 1}, - {&__pyx_n_s__38, __pyx_k__38, sizeof(__pyx_k__38), 0, 0, 1, 1}, + {&__pyx_n_s__40, __pyx_k__40, sizeof(__pyx_k__40), 0, 0, 1, 1}, {&__pyx_n_s_ann_var, __pyx_k_ann_var, sizeof(__pyx_k_ann_var), 0, 0, 1, 1}, {&__pyx_n_s_ann_z, __pyx_k_ann_z, sizeof(__pyx_k_ann_z), 0, 0, 1, 1}, {&__pyx_n_s_ann_z_halo, __pyx_k_ann_z_halo, sizeof(__pyx_k_ann_z_halo), 0, 0, 1, 1}, {&__pyx_n_s_ann_zmax, __pyx_k_ann_zmax, sizeof(__pyx_k_ann_zmax), 0, 0, 1, 1}, {&__pyx_n_s_ann_zmin, __pyx_k_ann_zmin, sizeof(__pyx_k_ann_zmin), 0, 0, 1, 1}, {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_call_decay_rate_pmf_turbulences, __pyx_k_call_decay_rate_pmf_turbulences, sizeof(__pyx_k_call_decay_rate_pmf_turbulences), 0, 0, 1, 1}, {&__pyx_n_s_call_run_hyrec, __pyx_k_call_run_hyrec, sizeof(__pyx_k_call_run_hyrec), 0, 0, 1, 1}, {&__pyx_n_s_category, __pyx_k_category, sizeof(__pyx_k_category), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, @@ -7828,6 +8017,7 @@ static int __Pyx_CreateStringTabAndInitStrings(void) { {&__pyx_n_s_mnu1, __pyx_k_mnu1, sizeof(__pyx_k_mnu1), 0, 0, 1, 1}, {&__pyx_n_s_mnu2, __pyx_k_mnu2, sizeof(__pyx_k_mnu2), 0, 0, 1, 1}, {&__pyx_n_s_mnu3, __pyx_k_mnu3, sizeof(__pyx_k_mnu3), 0, 0, 1, 1}, + {&__pyx_n_s_nB, __pyx_k_nB, sizeof(__pyx_k_nB), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, @@ -7846,6 +8036,7 @@ static int __Pyx_CreateStringTabAndInitStrings(void) { {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, {&__pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx, __pyx_k_src_pyhyrec_wrapperhyrec_pyx, sizeof(__pyx_k_src_pyhyrec_wrapperhyrec_pyx), 0, 0, 1, 0}, {&__pyx_n_s_str_table_location, __pyx_k_str_table_location, sizeof(__pyx_k_str_table_location), 0, 0, 1, 1}, + {&__pyx_n_s_tdti, __pyx_k_tdti, sizeof(__pyx_k_tdti), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_kp_s_utf_8, __pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 0, 1, 0}, {&__pyx_n_s_w0, __pyx_k_w0, sizeof(__pyx_k_w0), 0, 0, 1, 1}, @@ -7864,8 +8055,8 @@ static int __Pyx_CreateStringTabAndInitStrings(void) { } /* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_n_s_print); if (!__pyx_builtin_print) __PYX_ERR(0, 74, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_n_s_print); if (!__pyx_builtin_print) __PYX_ERR(0, 73, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 81, __pyx_L1_error) __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(1, 19, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 20, __pyx_L1_error) return 0; @@ -8179,41 +8370,52 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); - /* "pyhyrec/wrapperhyrec.pyx":64 + /* "pyhyrec/wrapperhyrec.pyx":63 * Array with size `nz` of the inter-galactic medium temperature [in K] * """ * def call_run_hyrec(INPUT_COSMOPARAMS cosmo_params, INPUT_INJ_PARAMS inj_params, double zmax = 8000.0, double zmin = 0.0, int nz = 8000): # <<<<<<<<<<<<<< * * str_table_location = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'data/') */ - __pyx_tuple__32 = PyTuple_Pack(13, __pyx_n_s_cosmo_params, __pyx_n_s_inj_params, __pyx_n_s_zmax, __pyx_n_s_zmin, __pyx_n_s_nz, __pyx_n_s_str_table_location, __pyx_n_s_cstr_table_location, __pyx_n_s_data_2, __pyx_n_s_z_array, __pyx_n_s_xe_array, __pyx_n_s_Tm_array, __pyx_n_s_iz, __pyx_n_s_z); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_tuple__32 = PyTuple_Pack(13, __pyx_n_s_cosmo_params, __pyx_n_s_inj_params, __pyx_n_s_zmax, __pyx_n_s_zmin, __pyx_n_s_nz, __pyx_n_s_str_table_location, __pyx_n_s_cstr_table_location, __pyx_n_s_data_2, __pyx_n_s_z_array, __pyx_n_s_xe_array, __pyx_n_s_Tm_array, __pyx_n_s_iz, __pyx_n_s_z); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); - __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx, __pyx_n_s_call_run_hyrec, 64, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx, __pyx_n_s_call_run_hyrec, 63, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 63, __pyx_L1_error) - /* "pyhyrec/wrapperhyrec.pyx":93 + /* "pyhyrec/wrapperhyrec.pyx":92 * * * def init_INPUT_INJ_PARAMS(double pann, double pann_halo, # <<<<<<<<<<<<<< * double ann_z, double ann_zmax, double ann_zmin, double ann_var, * double ann_z_halo, double decay, int on_the_spot, */ - __pyx_tuple__34 = PyTuple_Pack(12, __pyx_n_s_pann, __pyx_n_s_pann_halo, __pyx_n_s_ann_z, __pyx_n_s_ann_zmax, __pyx_n_s_ann_zmin, __pyx_n_s_ann_var, __pyx_n_s_ann_z_halo, __pyx_n_s_decay, __pyx_n_s_on_the_spot, __pyx_n_s_Mpbh, __pyx_n_s_fpbh, __pyx_n_s_inj_params); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 93, __pyx_L1_error) + __pyx_tuple__34 = PyTuple_Pack(12, __pyx_n_s_pann, __pyx_n_s_pann_halo, __pyx_n_s_ann_z, __pyx_n_s_ann_zmax, __pyx_n_s_ann_zmin, __pyx_n_s_ann_var, __pyx_n_s_ann_z_halo, __pyx_n_s_decay, __pyx_n_s_on_the_spot, __pyx_n_s_Mpbh, __pyx_n_s_fpbh, __pyx_n_s_inj_params); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 92, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); - __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(11, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx, __pyx_n_s_init_INPUT_INJ_PARAMS, 93, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 93, __pyx_L1_error) + __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(11, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx, __pyx_n_s_init_INPUT_INJ_PARAMS, 92, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 92, __pyx_L1_error) - /* "pyhyrec/wrapperhyrec.pyx":115 + /* "pyhyrec/wrapperhyrec.pyx":114 * * * def init_INPUT_COSMOPARAMS(double h, double T0, # <<<<<<<<<<<<<< * double Omega_b, double Omega_cb, double Omega_k, * double w0, double wa, double Neff, double Nmnu, */ - __pyx_tuple__36 = PyTuple_Pack(16, __pyx_n_s_h, __pyx_n_s_T0, __pyx_n_s_Omega_b, __pyx_n_s_Omega_cb, __pyx_n_s_Omega_k, __pyx_n_s_w0, __pyx_n_s_wa, __pyx_n_s_Neff, __pyx_n_s_Nmnu, __pyx_n_s_mnu1, __pyx_n_s_mnu2, __pyx_n_s_mnu3, __pyx_n_s_YHe, __pyx_n_s_fsR, __pyx_n_s_meR, __pyx_n_s_cosmo); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 115, __pyx_L1_error) + __pyx_tuple__36 = PyTuple_Pack(16, __pyx_n_s_h, __pyx_n_s_T0, __pyx_n_s_Omega_b, __pyx_n_s_Omega_cb, __pyx_n_s_Omega_k, __pyx_n_s_w0, __pyx_n_s_wa, __pyx_n_s_Neff, __pyx_n_s_Nmnu, __pyx_n_s_mnu1, __pyx_n_s_mnu2, __pyx_n_s_mnu3, __pyx_n_s_YHe, __pyx_n_s_fsR, __pyx_n_s_meR, __pyx_n_s_cosmo); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); - __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(15, 0, 0, 16, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx, __pyx_n_s_init_INPUT_COSMOPARAMS, 115, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 115, __pyx_L1_error) + __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(15, 0, 0, 16, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx, __pyx_n_s_init_INPUT_COSMOPARAMS, 114, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 114, __pyx_L1_error) + + /* "pyhyrec/wrapperhyrec.pyx":147 + * + * + * def call_decay_rate_pmf_turbulences(double z, double tdti, double nB): # <<<<<<<<<<<<<< + * return decay_rate_pmf_turbulences(z, tdti, nB) + */ + __pyx_tuple__38 = PyTuple_Pack(3, __pyx_n_s_z, __pyx_n_s_tdti, __pyx_n_s_nB); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__38); + __Pyx_GIVEREF(__pyx_tuple__38); + __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyhyrec_wrapperhyrec_pyx, __pyx_n_s_call_decay_rate_pmf_turbulences, 147, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 147, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -8646,59 +8848,70 @@ if (!__Pyx_RefNanny) { __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "pyhyrec/wrapperhyrec.pyx":64 + /* "pyhyrec/wrapperhyrec.pyx":63 * Array with size `nz` of the inter-galactic medium temperature [in K] * """ * def call_run_hyrec(INPUT_COSMOPARAMS cosmo_params, INPUT_INJ_PARAMS inj_params, double zmax = 8000.0, double zmin = 0.0, int nz = 8000): # <<<<<<<<<<<<<< * * str_table_location = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'data/') */ - __pyx_t_3 = PyFloat_FromDouble(((double)8000.0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(((double)8000.0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(((double)0.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyInt_From_int(((int)0x1F40)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(((int)0x1F40)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 64, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4)) __PYX_ERR(0, 63, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7pyhyrec_12wrapperhyrec_3call_run_hyrec, 0, __pyx_n_s_call_run_hyrec, NULL, __pyx_n_s_pyhyrec_wrapperhyrec, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7pyhyrec_12wrapperhyrec_3call_run_hyrec, 0, __pyx_n_s_call_run_hyrec, NULL, __pyx_n_s_pyhyrec_wrapperhyrec, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_call_run_hyrec, __pyx_t_4) < 0) __PYX_ERR(0, 64, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_call_run_hyrec, __pyx_t_4) < 0) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "pyhyrec/wrapperhyrec.pyx":93 + /* "pyhyrec/wrapperhyrec.pyx":92 * * * def init_INPUT_INJ_PARAMS(double pann, double pann_halo, # <<<<<<<<<<<<<< * double ann_z, double ann_zmax, double ann_zmin, double ann_var, * double ann_z_halo, double decay, int on_the_spot, */ - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7pyhyrec_12wrapperhyrec_5init_INPUT_INJ_PARAMS, 0, __pyx_n_s_init_INPUT_INJ_PARAMS, NULL, __pyx_n_s_pyhyrec_wrapperhyrec, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 93, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7pyhyrec_12wrapperhyrec_5init_INPUT_INJ_PARAMS, 0, __pyx_n_s_init_INPUT_INJ_PARAMS, NULL, __pyx_n_s_pyhyrec_wrapperhyrec, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 92, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_init_INPUT_INJ_PARAMS, __pyx_t_4) < 0) __PYX_ERR(0, 93, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_init_INPUT_INJ_PARAMS, __pyx_t_4) < 0) __PYX_ERR(0, 92, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "pyhyrec/wrapperhyrec.pyx":115 + /* "pyhyrec/wrapperhyrec.pyx":114 * * * def init_INPUT_COSMOPARAMS(double h, double T0, # <<<<<<<<<<<<<< * double Omega_b, double Omega_cb, double Omega_k, * double w0, double wa, double Neff, double Nmnu, */ - __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7pyhyrec_12wrapperhyrec_7init_INPUT_COSMOPARAMS, 0, __pyx_n_s_init_INPUT_COSMOPARAMS, NULL, __pyx_n_s_pyhyrec_wrapperhyrec, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 115, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7pyhyrec_12wrapperhyrec_7init_INPUT_COSMOPARAMS, 0, __pyx_n_s_init_INPUT_COSMOPARAMS, NULL, __pyx_n_s_pyhyrec_wrapperhyrec, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_init_INPUT_COSMOPARAMS, __pyx_t_4) < 0) __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "pyhyrec/wrapperhyrec.pyx":147 + * + * + * def call_decay_rate_pmf_turbulences(double z, double tdti, double nB): # <<<<<<<<<<<<<< + * return decay_rate_pmf_turbulences(z, tdti, nB) + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_7pyhyrec_12wrapperhyrec_9call_decay_rate_pmf_turbulences, 0, __pyx_n_s_call_decay_rate_pmf_turbulences, NULL, __pyx_n_s_pyhyrec_wrapperhyrec, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_init_INPUT_COSMOPARAMS, __pyx_t_4) < 0) __PYX_ERR(0, 115, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_call_decay_rate_pmf_turbulences, __pyx_t_4) < 0) __PYX_ERR(0, 147, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyhyrec/wrapperhyrec.pyx":2 @@ -11557,7 +11770,7 @@ static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, default: return NULL; } - return ((_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); } static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { @@ -12621,7 +12834,7 @@ __Pyx_PyType_GetName(PyTypeObject* tp) if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { PyErr_Clear(); Py_XDECREF(name); - name = __Pyx_NewRef(__pyx_n_s__38); + name = __Pyx_NewRef(__pyx_n_s__40); } return name; } diff --git a/src/pyhyrec/wrapperhyrec.pyx b/src/pyhyrec/wrapperhyrec.pyx index 6c7205e..77e2bbd 100644 --- a/src/pyhyrec/wrapperhyrec.pyx +++ b/src/pyhyrec/wrapperhyrec.pyx @@ -12,7 +12,6 @@ warnings.formatwarning = warning_on_one_line cdef extern from "src/history.h": - ctypedef struct INPUT_INJ_PARAMS: double pann, #/* DM annihilation parameter in the smooth background and in haloes */ @@ -107,7 +106,7 @@ def init_INPUT_INJ_PARAMS(double pann, double pann_halo, inj_params.decay = decay inj_params.on_the_spot = on_the_spot inj_params.Mpbh = Mpbh - inj_params.fpbh = fpbh + inj_params.fpbh = fpbh return inj_params @@ -137,3 +136,13 @@ def init_INPUT_COSMOPARAMS(double h, double T0, cosmo.meR = meR return cosmo; + + + +cdef extern from "src/energy_injection.h": + + double decay_rate_pmf_turbulences(double z, double tdti, double nB) + + +def call_decay_rate_pmf_turbulences(double z, double tdti, double nB): + return decay_rate_pmf_turbulences(z, tdti, nB) \ No newline at end of file