From 9388d5479489c905ed92a83a59db95d7b56fdb3e Mon Sep 17 00:00:00 2001 From: Michael Zingale Date: Tue, 24 Oct 2023 11:44:59 -0400 Subject: [PATCH] start of a tool to make the tabel --- networks/aprox19/README.md | 9 + networks/nse_table/make_nse_table.py | 118 +++++++ networks/nse_table/nse_table.ipynb | 488 ++++++++++++++++++--------- 3 files changed, 457 insertions(+), 158 deletions(-) create mode 100644 networks/nse_table/make_nse_table.py diff --git a/networks/aprox19/README.md b/networks/aprox19/README.md index 8c8bf7ae94..af37b57d00 100644 --- a/networks/aprox19/README.md +++ b/networks/aprox19/README.md @@ -10,3 +10,12 @@ species and reaction rates. We thank Frank for allowing us to redistribute these routines. We can use the tabulated NSE together with this network. + +---- + +Note: there are 2 protons in this network. + +* `H1` is hydrogen that participates in the p-p chain and CNO cycle + +* `p` are protons that result from photodisintegration and participate + in the NSE at the Fe-group diff --git a/networks/nse_table/make_nse_table.py b/networks/nse_table/make_nse_table.py new file mode 100644 index 0000000000..1009696059 --- /dev/null +++ b/networks/nse_table/make_nse_table.py @@ -0,0 +1,118 @@ +import pynucastro as pyna +from pynucastro import Nucleus + + +class NSEState: + def __init__(self, rho, T, comp, rc): + self.rho = rho + self.T = T + self.comp = comp + self.rc = rc + + self.ydots = rc.evaluate_ydots(self.rho, self.T, self.comp, + screen_func=pyna.screening.potekhin_1998, + rate_filter=lambda r: isinstance(r, pyna.rates.TabularRate)) + + def get_abar(self): + return self.comp.eval_abar() + + def get_bea(self): + return sum(q.nucbind * self.comp.X[q] for q in self.comp.X) + + def get_dyedt(self): + return sum(q.Z * self.ydots[q] for q in self.comp.X) + + def get_dabardt(self): + abar = self.get_abar() + return -abar**2 * sum(self.ydots[q] for q in self.comp.X) + + def get_enu(self): + _, enu = self.rc.evaluate_energy_generation(self.rho, self.T, self.comp, + screen_func=pyna.screening.potekhin_1998, + return_enu=True) + return enu + + def get_aprox19_comp(self): + aprox19_comp = [Nucleus("he3"), Nucleus("he4"), Nucleus("c12"), Nucleus("n14"), + Nucleus("o16"), Nucleus("ne20"), Nucleus("mg24"), Nucleus("si28"), + Nucleus("s32"), Nucleus("ar36"), Nucleus("ca40"), Nucleus("ti44"), + Nucleus("cr48"), Nucleus("fe52"), Nucleus("fe54"), Nucleus("ni56"), + Nucleus("n"), Nucleus("p")] + reduced_comp = self.comp.bin_as(aprox19_comp, exclude=[Nucleus("ni56")]) + + # the actual aprox19 network has 2 protons, one is the NSE proton + # and the other is H that participates in H-burning. We need to + # to add H1 with zero abundance in our return + + # we also want to preserve the order that aprox19 uses + X = [] + X.append(("H1", 0.0)) + X.append(("He3", reduced_comp.X[Nucleus("he3")])) + X.append(("He4", reduced_comp.X[Nucleus("he4")])) + X.append(("C12", reduced_comp.X[Nucleus("c12")])) + X.append(("N14", reduced_comp.X[Nucleus("n14")])) + X.append(("O16", reduced_comp.X[Nucleus("o16")])) + X.append(("Ne20", reduced_comp.X[Nucleus("ne20")])) + X.append(("Mg24", reduced_comp.X[Nucleus("mg24")])) + X.append(("Si28", reduced_comp.X[Nucleus("si28")])) + X.append(("S32", reduced_comp.X[Nucleus("s32")])) + X.append(("Ar36", reduced_comp.X[Nucleus("ar36")])) + X.append(("Ca40", reduced_comp.X[Nucleus("ca40")])) + X.append(("Ti44", reduced_comp.X[Nucleus("ti44")])) + X.append(("Cr48", reduced_comp.X[Nucleus("cr48")])) + X.append(("Fe52", reduced_comp.X[Nucleus("fe52")])) + X.append(("Fe54", reduced_comp.X[Nucleus("fe54")])) + X.append(("Ni56", reduced_comp.X[Nucleus("ni56")])) + X.append(("n", reduced_comp.X[Nucleus("n")])) + X.append(("p", reduced_comp.X[Nucleus("p")])) + + return X + +def make_nse_network(): + + # list of nuclei we care about + + nuc_list = [Nucleus("n"), Nucleus("p"), Nucleus("d"), + Nucleus("he3"), Nucleus("he4"), Nucleus("c12"), Nucleus("o16"), + Nucleus("n13"), Nucleus("n14"), Nucleus("f18"), + Nucleus("ne20"), Nucleus("ne21"), Nucleus("ne22"), + Nucleus("na23"), Nucleus("mg24"), Nucleus("si28"), + Nucleus("s32"), Nucleus("ar36"), Nucleus("ca40"), Nucleus("sc43"), + Nucleus("al27"), Nucleus("p31"), Nucleus("cl35"), Nucleus("k39")] + + nuc_list += pyna.get_nuclei_in_range(20, 20, 45, 48) # Ca + nuc_list += pyna.get_nuclei_in_range(21, 21, 45, 49) # Sc + nuc_list += pyna.get_nuclei_in_range(22, 22, 44, 52) # Ti + nuc_list += pyna.get_nuclei_in_range(23, 23, 47, 54) # V + nuc_list += pyna.get_nuclei_in_range(24, 24, 48, 56) # Cr + nuc_list += pyna.get_nuclei_in_range(25, 25, 51, 58) # Mn + nuc_list += pyna.get_nuclei_in_range(26, 26, 52, 60) # Fe + nuc_list += pyna.get_nuclei_in_range(27, 27, 54, 61) # Co + nuc_list += pyna.get_nuclei_in_range(28, 28, 56, 65) # Ni + nuc_list.append(Nucleus("cu59")) + nuc_list.append(Nucleus("zn60")) + + # create the library + + tl = pyna.TabularLibrary() + rl = pyna.ReacLibLibrary() + tlib = tl.linking_nuclei(nuc_list) + rlib = rl.linking_nuclei(nuc_list) + + all_lib = rlib + tlib + + # remove dupes + + dupes = all_lib.find_duplicate_links() + + rates_to_remove = [] + for d in dupes: + rates_to_remove += [r for r in d if isinstance(r, pyna.rates.ReacLibRate)] + + for r in rates_to_remove: + all_lib.remove_rate(r) + + # create the rate collection + + rc = pyna.RateCollection(libraries=[all_lib]) + diff --git a/networks/nse_table/nse_table.ipynb b/networks/nse_table/nse_table.ipynb index 3700ff7fa5..23bf66de55 100644 --- a/networks/nse_table/nse_table.ipynb +++ b/networks/nse_table/nse_table.ipynb @@ -154,34 +154,34 @@ "name": "stdout", "output_type": "stream", "text": [ - "warning: ti44 was not able to be linked\n", - "warning: na23 was not able to be linked\n", - "warning: k39 was not able to be linked\n", - "warning: he4 was not able to be linked\n", - "warning: ca40 was not able to be linked\n", - "warning: ne20 was not able to be linked\n", - "warning: ni62 was not able to be linked\n", - "warning: ne22 was not able to be linked\n", - "warning: n14 was not able to be linked\n", - "warning: ni64 was not able to be linked\n", - "warning: si28 was not able to be linked\n", - "warning: sc43 was not able to be linked\n", - "warning: mg24 was not able to be linked\n", - "warning: ne21 was not able to be linked\n", - "warning: ni63 was not able to be linked\n", + "warning: Ti44 was not able to be linked\n", + "warning: Na23 was not able to be linked\n", + "warning: K39 was not able to be linked\n", + "warning: He4 was not able to be linked\n", + "warning: Ca40 was not able to be linked\n", + "warning: Ne20 was not able to be linked\n", + "warning: Ni62 was not able to be linked\n", + "warning: Ne22 was not able to be linked\n", + "warning: N14 was not able to be linked\n", + "warning: Ni64 was not able to be linked\n", + "warning: Si28 was not able to be linked\n", + "warning: Sc43 was not able to be linked\n", + "warning: Mg24 was not able to be linked\n", + "warning: Ne21 was not able to be linked\n", + "warning: Ni63 was not able to be linked\n", "warning: d was not able to be linked\n", - "warning: p31 was not able to be linked\n", - "warning: ar36 was not able to be linked\n", - "warning: he3 was not able to be linked\n", - "warning: f18 was not able to be linked\n", - "warning: c12 was not able to be linked\n", - "warning: al27 was not able to be linked\n", - "warning: s32 was not able to be linked\n", - "warning: n13 was not able to be linked\n", - "warning: zn60 was not able to be linked\n", - "warning: cl35 was not able to be linked\n", - "warning: ni65 was not able to be linked\n", - "warning: o16 was not able to be linked\n" + "warning: P31 was not able to be linked\n", + "warning: Ar36 was not able to be linked\n", + "warning: He3 was not able to be linked\n", + "warning: F18 was not able to be linked\n", + "warning: C12 was not able to be linked\n", + "warning: Al27 was not able to be linked\n", + "warning: S32 was not able to be linked\n", + "warning: N13 was not able to be linked\n", + "warning: Zn60 was not able to be linked\n", + "warning: Cl35 was not able to be linked\n", + "warning: Ni65 was not able to be linked\n", + "warning: O16 was not able to be linked\n" ] } ], @@ -240,140 +240,140 @@ "n__p__weak__wc12 \n", "n__p \n", "\n", - "ca45__sc45__weak__wc12 \n", - "ca45__sc45 \n", + "Ca45__Sc45__weak__wc12 \n", + "Ca45__Sc45 \n", "\n", - "ca47__sc47__weak__wc12 \n", - "ca47__sc47 \n", + "Ca47__Sc47__weak__wc12 \n", + "Ca47__Sc47 \n", "\n", - "ca48__sc48__weak__mo03 \n", - "ca48__sc48 \n", + "Ca48__Sc48__weak__mo03 \n", + "Ca48__Sc48 \n", "\n", - "sc46__ti46__weak__wc12 \n", - "sc46__ti46 \n", + "Sc46__Ti46__weak__wc12 \n", + "Sc46__Ti46 \n", "\n", - "sc47__ti47__weak__wc12 \n", - "sc47__ti47 \n", + "Sc47__Ti47__weak__wc12 \n", + "Sc47__Ti47 \n", "\n", - "sc48__ti48__weak__wc12 \n", - "sc48__ti48 \n", + "Sc48__Ti48__weak__wc12 \n", + "Sc48__Ti48 \n", "\n", - "sc49__ti49__weak__wc12 \n", - "sc49__ti49 \n", + "Sc49__Ti49__weak__wc12 \n", + "Sc49__Ti49 \n", "\n", - "ti45__sc45__weak__wc12 \n", - "ti45__sc45 \n", + "Ti45__Sc45__weak__wc12 \n", + "Ti45__Sc45 \n", "\n", - "ti51__v51__weak__wc12 \n", - "ti51__v51 \n", + "Ti51__V51__weak__wc12 \n", + "Ti51__V51 \n", "\n", - "ti52__v52__weak__wc12 \n", - "ti52__v52 \n", + "Ti52__V52__weak__wc12 \n", + "Ti52__V52 \n", "\n", - "v47__ti47__weak__wc12 \n", - "v47__ti47 \n", + "V47__Ti47__weak__wc12 \n", + "V47__Ti47 \n", "\n", - "v48__ti48__weak__wc12 \n", - "v48__ti48 \n", + "V48__Ti48__weak__wc12 \n", + "V48__Ti48 \n", "\n", - "v49__ti49__weak__wc12 \n", - "v49__ti49 \n", + "V49__Ti49__weak__wc12 \n", + "V49__Ti49 \n", "\n", - "v50__ti50__weak__mo03 \n", - "v50__ti50 \n", + "V50__Ti50__weak__mo03 \n", + "V50__Ti50 \n", "\n", - "v52__cr52__weak__wc12 \n", - "v52__cr52 \n", + "V52__Cr52__weak__wc12 \n", + "V52__Cr52 \n", "\n", - "v53__cr53__weak__wc12 \n", - "v53__cr53 \n", + "V53__Cr53__weak__wc12 \n", + "V53__Cr53 \n", "\n", - "v54__cr54__weak__wc12 \n", - "v54__cr54 \n", + "V54__Cr54__weak__wc12 \n", + "V54__Cr54 \n", "\n", - "cr48__v48__weak__wc12 \n", - "cr48__v48 \n", + "Cr48__V48__weak__wc12 \n", + "Cr48__V48 \n", "\n", - "cr49__v49__weak__wc12 \n", - "cr49__v49 \n", + "Cr49__V49__weak__wc12 \n", + "Cr49__V49 \n", "\n", - "cr51__v51__weak__wc12 \n", - "cr51__v51 \n", + "Cr51__V51__weak__wc12 \n", + "Cr51__V51 \n", "\n", - "cr55__mn55__weak__wc12 \n", - "cr55__mn55 \n", + "Cr55__Mn55__weak__wc12 \n", + "Cr55__Mn55 \n", "\n", - "cr56__mn56__weak__wc12 \n", - "cr56__mn56 \n", + "Cr56__Mn56__weak__wc12 \n", + "Cr56__Mn56 \n", "\n", - "mn51__cr51__weak__wc12 \n", - "mn51__cr51 \n", + "Mn51__Cr51__weak__wc12 \n", + "Mn51__Cr51 \n", "\n", - "mn52__cr52__weak__wc12 \n", - "mn52__cr52 \n", + "Mn52__Cr52__weak__wc12 \n", + "Mn52__Cr52 \n", "\n", - "mn53__cr53__weak__wc12 \n", - "mn53__cr53 \n", + "Mn53__Cr53__weak__wc12 \n", + "Mn53__Cr53 \n", "\n", - "mn54__cr54__weak__wc12 \n", - "mn54__cr54 \n", + "Mn54__Cr54__weak__wc12 \n", + "Mn54__Cr54 \n", "\n", - "mn56__fe56__weak__wc12 \n", - "mn56__fe56 \n", + "Mn56__Fe56__weak__wc12 \n", + "Mn56__Fe56 \n", "\n", - "mn57__fe57__weak__wc12 \n", - "mn57__fe57 \n", + "Mn57__Fe57__weak__wc12 \n", + "Mn57__Fe57 \n", "\n", - "mn58__fe58__weak__wc12 \n", - "mn58__fe58 \n", + "Mn58__Fe58__weak__wc12 \n", + "Mn58__Fe58 \n", "\n", - "fe52__mn52__weak__wc12 \n", - "fe52__mn52 \n", + "Fe52__Mn52__weak__wc12 \n", + "Fe52__Mn52 \n", "\n", - "fe53__mn53__weak__wc12 \n", - "fe53__mn53 \n", + "Fe53__Mn53__weak__wc12 \n", + "Fe53__Mn53 \n", "\n", - "fe55__mn55__weak__wc12 \n", - "fe55__mn55 \n", + "Fe55__Mn55__weak__wc12 \n", + "Fe55__Mn55 \n", "\n", - "fe59__co59__weak__wc12 \n", - "fe59__co59 \n", + "Fe59__Co59__weak__wc12 \n", + "Fe59__Co59 \n", "\n", - "fe60__co60__weak__wc12 \n", - "fe60__co60 \n", + "Fe60__Co60__weak__wc12 \n", + "Fe60__Co60 \n", "\n", - "co54__fe54__weak__wc12 \n", - "co54__fe54 \n", + "Co54__Fe54__weak__wc12 \n", + "Co54__Fe54 \n", "\n", - "co55__fe55__weak__wc12 \n", - "co55__fe55 \n", + "Co55__Fe55__weak__wc12 \n", + "Co55__Fe55 \n", "\n", - "co56__fe56__weak__wc12 \n", - "co56__fe56 \n", + "Co56__Fe56__weak__wc12 \n", + "Co56__Fe56 \n", "\n", - "co57__fe57__weak__wc12 \n", - "co57__fe57 \n", + "Co57__Fe57__weak__wc12 \n", + "Co57__Fe57 \n", "\n", - "co58__fe58__weak__wc12 \n", - "co58__fe58 \n", + "Co58__Fe58__weak__wc12 \n", + "Co58__Fe58 \n", "\n", - "co60__ni60__weak__wc12 \n", - "co60__ni60 \n", + "Co60__Ni60__weak__wc12 \n", + "Co60__Ni60 \n", "\n", - "co61__ni61__weak__wc12 \n", - "co61__ni61 \n", + "Co61__Ni61__weak__wc12 \n", + "Co61__Ni61 \n", "\n", - "ni56__co56__weak__wc12 \n", - "ni56__co56 \n", + "Ni56__Co56__weak__wc12 \n", + "Ni56__Co56 \n", "\n", - "ni57__co57__weak__wc12 \n", - "ni57__co57 \n", + "Ni57__Co57__weak__wc12 \n", + "Ni57__Co57 \n", "\n", - "ni59__co59__weak__wc12 \n", - "ni59__co59 \n", + "Ni59__Co59__weak__wc12 \n", + "Ni59__Co59 \n", "\n", - "cu59__ni59__weak__wc12 \n", - "cu59__ni59 \n", + "Cu59__Ni59__weak__wc12 \n", + "Cu59__Ni59 \n", "\n" ] } @@ -521,14 +521,14 @@ }, "outputs": [], "source": [ - "rho = 1.23e9\n", - "T = 5.18e9\n", - "Ye = 0.472" + "rho = 1.8e9\n", + "T = 6.6e9\n", + "Ye = 0.464" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 15, "id": "7ff0ed3f-38ce-4234-b46a-5254506528fb", "metadata": { "tags": [] @@ -540,7 +540,31 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 16, + "id": "8fdb2c11-4eb3-436f-82d1-cfa739eef753", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "52.10820218271818" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "abar = 0.0\n", + "for n in comp.X:\n", + " abar += comp.X[n] / n.A\n", + "1.0/abar" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "id": "f291a79e-afa7-40ab-bb0a-a0915f511c12", "metadata": { "tags": [] @@ -548,7 +572,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -572,7 +596,7 @@ "\n", "We want our NSE table to take the form:\n", "\n", - "$\\mathrm{NSE}(\\rho, T, Y_e) \\rightarrow (\\bar{A}, \\langle B/A\\rangle, dY_e/dt, d\\bar{A}/dt, \\tilde{X}_k)$\n", + "$\\mathrm{NSE}(\\rho, T, Y_e) \\rightarrow (\\bar{A}, \\langle B/A\\rangle, dY_e/dt, d\\bar{A}/dt, \\tilde{X}_k, \\epsilon_{\\nu,\\mathrm{weak}})$\n", "\n", "where:\n", "\n", @@ -605,7 +629,9 @@ " $$\\frac{d\\bar{A}}{dt} = -\\bar{A}^2 \\sum_k \\frac{dY_k}{dt}$$\n", "\n", "* $\\tilde{X}_k$ is are the reduced set of nuclei mass fractions, obtained by binning the full set of mass fractions\n", - " obtained via NSE down to the collection we will carry on the grid." + " obtained via NSE down to the collection we will carry on the grid.\n", + "\n", + "* $\\epsilon_{\\nu,\\mathrm{weak}}$ are the neutrino losses from the weak reactions" ] }, { @@ -623,7 +649,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 18, "id": "313f595f-8fd6-45a5-8a65-74405d62c8f8", "metadata": { "tags": [] @@ -632,10 +658,10 @@ { "data": { "text/plain": [ - "55.60645272576828" + "52.10820218271818" ] }, - "execution_count": 23, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -659,7 +685,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 19, "id": "801fa5bf-83f5-4404-9523-6047910ce6ed", "metadata": { "tags": [] @@ -668,10 +694,10 @@ { "data": { "text/plain": [ - "8.755113254853534" + "8.757823874219824" ] }, - "execution_count": 24, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -696,7 +722,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 20, "id": "d766fc20-53dc-4225-8b7f-8e8825972afd", "metadata": { "tags": [] @@ -710,7 +736,123 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 21, + "id": "84cc45a9-1892-4705-825f-46a92184d694", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{n: 0.0006346506303224716,\n", + " p: -0.0006346506303224716,\n", + " d: 0,\n", + " He3: 0,\n", + " He4: 0,\n", + " C12: 0,\n", + " N13: 0,\n", + " N14: 0,\n", + " O16: 0,\n", + " F18: 0,\n", + " Ne20: 0,\n", + " Ne21: 0,\n", + " Ne22: 0,\n", + " Na23: 0,\n", + " Mg24: 0,\n", + " Al27: 0,\n", + " Si28: 0,\n", + " P31: 0,\n", + " S32: 0,\n", + " Cl35: 0,\n", + " Ar36: 0,\n", + " K39: 0,\n", + " Ca40: 0,\n", + " Ca45: 1.0446102494105053e-07,\n", + " Ca46: 2.9661842665261547e-08,\n", + " Ca47: 4.7719558956034354e-09,\n", + " Ca48: 1.1901935394486482e-09,\n", + " Sc43: 0,\n", + " Sc45: 5.849051764944439e-08,\n", + " Sc46: 2.99028428023127e-07,\n", + " Sc47: 8.898631678399081e-07,\n", + " Sc48: 3.399439413614359e-07,\n", + " Sc49: 3.0102025877182856e-07,\n", + " Ti44: 0,\n", + " Ti45: -1.6295154259049493e-07,\n", + " Ti46: -3.286902706883885e-07,\n", + " Ti47: -7.503967331170383e-08,\n", + " Ti48: 3.7714000811612757e-06,\n", + " Ti49: 1.596130044521697e-05,\n", + " Ti50: 9.977443215716377e-06,\n", + " Ti51: 6.6276750495625016e-06,\n", + " Ti52: 2.9551379390441167e-07,\n", + " V47: -8.195954504238076e-07,\n", + " V48: -3.926158500027479e-06,\n", + " V49: -1.2576237633584542e-05,\n", + " V50: 5.6809038420201324e-05,\n", + " V51: 0.00011500155751481232,\n", + " V52: 0.00011071485096381298,\n", + " V53: 2.5339002689647373e-05,\n", + " V54: 1.3400792225471498e-07,\n", + " Cr48: -1.8637571603468124e-07,\n", + " Cr49: -3.6860830704042566e-06,\n", + " Cr50: -6.67864816359177e-05,\n", + " Cr51: -0.00011266939103190762,\n", + " Cr52: -4.918782228769699e-05,\n", + " Cr53: 0.00036338583954758426,\n", + " Cr54: 0.00026801487511336807,\n", + " Cr55: 4.2140324756815996e-05,\n", + " Cr56: 2.0140278879632494e-06,\n", + " Mn51: -8.959841532467209e-06,\n", + " Mn52: -6.095990805000377e-05,\n", + " Mn53: -0.0003656750532726086,\n", + " Mn54: 0.0002753273490938034,\n", + " Mn55: 0.0009870392010937203,\n", + " Mn56: 0.0007038127062038469,\n", + " Mn57: 0.00012792206837703031,\n", + " Mn58: 1.4545197455245418e-06,\n", + " Fe52: -8.62634420016637e-07,\n", + " Fe53: -2.3049788964623023e-05,\n", + " Fe54: -0.0005432998479306308,\n", + " Fe55: -0.0009675111959398593,\n", + " Fe56: -0.0004651235553195307,\n", + " Fe57: 0.0004898580950904281,\n", + " Fe58: 0.000263343166684463,\n", + " Fe59: 5.390555221699837e-05,\n", + " Fe60: 4.528646646545631e-06,\n", + " Co54: -1.7638419879544862e-07,\n", + " Co55: -6.16683299106771e-05,\n", + " Co56: -0.0002371168395174725,\n", + " Co57: -0.000577562506987377,\n", + " Co58: -2.574031584037719e-05,\n", + " Co59: 0.0005051544229022399,\n", + " Co60: 0.00037059735355195964,\n", + " Co61: 0.00011876197862846228,\n", + " Ni56: -3.586339254806925e-06,\n", + " Ni57: -4.021765648008136e-05,\n", + " Ni58: -0.0002390573705896103,\n", + " Ni59: -0.0005573910393982045,\n", + " Ni60: -0.00037512600019850526,\n", + " Ni61: -0.00011876197862846228,\n", + " Ni62: 0,\n", + " Ni63: 0,\n", + " Ni64: 0,\n", + " Ni65: 0,\n", + " Cu59: -1.6689357210337184e-06,\n", + " Zn60: 0}" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ydots" + ] + }, + { + "cell_type": "code", + "execution_count": 22, "id": "9b64d04e-7ae6-4644-a846-b2df648302f8", "metadata": { "tags": [] @@ -719,10 +861,10 @@ { "data": { "text/plain": [ - "-0.004529975530721609" + "-0.00678830594058978" ] }, - "execution_count": 26, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -734,7 +876,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 23, "id": "bb0d147a-8cff-4f94-9b71-e16a80c3ba04", "metadata": { "tags": [] @@ -743,10 +885,10 @@ { "data": { "text/plain": [ - "-3.4310099825645205e-16" + "1.0418631669420682e-15" ] }, - "execution_count": 27, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -756,6 +898,36 @@ "dAbardt" ] }, + { + "cell_type": "markdown", + "id": "7c9e6b53-ecd2-47ed-bbd6-b8e45e28030b", + "metadata": {}, + "source": [ + "### Neutrino losses" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "75c9b0f8-5c95-4f33-b1bd-56bc5c219c13", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.0289817506466132e+16" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + " _, enu = rc.evaluate_energy_generation(rho, T, comp, screen_func=potekhin_1998, return_enu=True)\n", + "enu" + ] + }, { "cell_type": "markdown", "id": "6ec656a2-b6bb-4f9d-941a-4dabc4ca7681", @@ -768,7 +940,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 25, "id": "9bc0d08d-1070-4b42-b61d-e5cf2facd679", "metadata": { "tags": [] @@ -777,27 +949,27 @@ { "data": { "text/plain": [ - "{n: 2.0864486488508263e-08,\n", - " p: 9.854649134957798e-06,\n", - " he3: 2.7666891130341223e-14,\n", - " he4: 0.0003165051242076851,\n", - " c12: 8.007110655983918e-10,\n", - " n14: 3.150257779807441e-14,\n", - " o16: 2.0044430830378715e-09,\n", - " ne20: 2.4593295937640106e-11,\n", - " mg24: 1.0316130245885416e-08,\n", - " si28: 8.182350470627633e-06,\n", - " s32: 1.1956547526050164e-05,\n", - " ar36: 1.2451156657834769e-05,\n", - " ca40: 1.2631931022918352e-05,\n", - " ti44: 0.000143815973006118,\n", - " cr48: 0.011470132295457387,\n", - " fe52: 0.0774704132797848,\n", - " fe54: 0.9098270219037505,\n", - " ni56: 0.0007170007785309573}" + "{n: 8.169037085731664e-06,\n", + " p: 9.055872656307402e-05,\n", + " He3: 2.2816281611288373e-11,\n", + " He4: 0.005141457401413937,\n", + " C12: 1.0324294800325628e-07,\n", + " N14: 3.5947335188068174e-11,\n", + " O16: 1.3110395512730868e-07,\n", + " Ne20: 4.2954698651381495e-09,\n", + " Mg24: 4.1825916870265633e-07,\n", + " Si28: 2.8259378637801294e-05,\n", + " S32: 2.624325405695737e-05,\n", + " Ar36: 2.0312872101959887e-05,\n", + " Ca40: 6.570111614346066e-06,\n", + " Ti44: 0.0006581436017294,\n", + " Cr48: 0.02743261593609235,\n", + " Fe52: 0.13998944464897595,\n", + " Fe54: 0.826582340479613,\n", + " Ni56: 1.5227591828655356e-05}" ] }, - "execution_count": 29, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }