From 15238896e311fd6c04fe6476373070663f4d87ff Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 23 May 2024 12:41:44 -0500 Subject: [PATCH 01/50] AsterX: Add grid functions for advection of entropy density --- AsterX/interface.ccl | 6 ++++++ AsterX/schedule.ccl | 38 +++++++++++++++++++++----------------- 2 files changed, 27 insertions(+), 17 deletions(-) diff --git a/AsterX/interface.ccl b/AsterX/interface.ccl index d1829a79..dd2cc8fb 100644 --- a/AsterX/interface.ccl +++ b/AsterX/interface.ccl @@ -22,11 +22,14 @@ CCTK_REAL mom TYPE=gf CENTERING={ccc} TAGS='rhs="momrhs" dependents="HydroBaseX: CCTK_REAL tau TYPE=gf CENTERING={ccc} TAGS='rhs="taurhs" dependents="HydroBaseX::eps HydroBaseX::press HydroBaseX::temperature HydroBaseX::Ye HydroBaseX::Bvec TmunuBaseX::eTij"' "Conserved internal energy density" +CCTK_REAL sstar TYPE=gf CENTERING={ccc} TAGS='rhs="sstarrhs" dependents="HydroBaseX::entropy AsterX::flux_x AsterX::flux_y AsterX::flux_z"' "Advected entropy density" + CCTK_REAL flux_x TYPE=gf CENTERING={vcc} TAGS='checkpoint="no"' { fxdens fxmomx fxmomy fxmomz fxtau + fxsstar fxBx fxBy fxBz } "Fluxes in x direction" @@ -35,6 +38,7 @@ CCTK_REAL flux_y TYPE=gf CENTERING={cvc} TAGS='checkpoint="no"' fydens fymomx fymomy fymomz fytau + fysstar fyBx fyBy fyBz } "Fluxes in y direction" @@ -43,6 +47,7 @@ CCTK_REAL flux_z TYPE=gf CENTERING={ccv} TAGS='checkpoint="no"' fzdens fzmomx fzmomy fzmomz fztau + fzsstar fzBx fzBy fzBz } "Fluxes in z direction" @@ -55,6 +60,7 @@ CCTK_REAL momrhs TYPE=gf CENTERING={ccc} TAGS='checkpoint="no"' CCTK_REAL taurhs TYPE=gf CENTERING={ccc} TAGS='checkpoint="no"' "Conserved internal energy density RHS" +CCTK_REAL sstarrhs TYPE=gf CENTERING={ccc} TAGS='checkpoint="no"' "Advected entropy density RHS" CCTK_REAL Avec_x TYPE=gf CENTERING={cvv} TAGS='rhs="Avec_x_rhs"' "x-component of vector potential" CCTK_REAL Avec_y TYPE=gf CENTERING={vcv} TAGS='rhs="Avec_y_rhs"' "y-component of vector potential" diff --git a/AsterX/schedule.ccl b/AsterX/schedule.ccl index a5637ff1..5eea8664 100644 --- a/AsterX/schedule.ccl +++ b/AsterX/schedule.ccl @@ -1,8 +1,8 @@ # Schedule definitions for thorn AsterX -STORAGE: dens mom tau dB Psi HydroBaseX::Bvec dBx_stag dBy_stag dBz_stag +STORAGE: dens mom tau sstar dB Psi HydroBaseX::Bvec dBx_stag dBy_stag dBz_stag STORAGE: flux_x flux_y flux_z -STORAGE: densrhs momrhs taurhs Avec_x_rhs Avec_y_rhs Avec_z_rhs Psi_rhs +STORAGE: densrhs momrhs taurhs sstarrhs Avec_x_rhs Avec_y_rhs Avec_z_rhs Psi_rhs STORAGE: ADMBaseX::metric ADMBaseX::lapse ADMBaseX::shift ADMBaseX::curv STORAGE: Aux_in_RHSof_A_Psi STORAGE: TmunuBaseX::eTtt TmunuBaseX::eTti TmunuBaseX::eTij @@ -69,10 +69,11 @@ SCHEDULE AsterX_Prim2Con_Initial IN AsterX_InitialGroup AFTER AsterX_ComputeBFro LANG: C READS: ADMBaseX::metric(interior) READS: HydroBaseX::rho(interior) HydroBaseX::vel(interior) HydroBaseX::eps(interior) HydroBaseX::press(interior) HydroBaseX::Bvec(interior) - WRITES: dens(interior) tau(interior) mom(interior) dB(interior) + READS: HydroBaseX::entropy(interior) + WRITES: dens(interior) tau(interior) sstar(interior) mom(interior) dB(interior) WRITES: Psi(everywhere) WRITES: saved_prims - SYNC: dens tau mom dB + SYNC: dens tau sstar mom dB SYNC: saved_prims } "Compute conserved variables from primitive variables at initial" @@ -82,7 +83,7 @@ SCHEDULE AsterX_Sync AT postregrid { LANG: C OPTIONS: global - SYNC: dens tau mom Avec_x Avec_y Avec_z Psi + SYNC: dens tau mom sstar Avec_x Avec_y Avec_z Psi SYNC: saved_prims } "Synchronize" @@ -90,7 +91,7 @@ SCHEDULE AsterX_Sync IN ODESolvers_PostStep { LANG: C OPTIONS: global - SYNC: dens tau mom Avec_x Avec_y Avec_z Psi + SYNC: dens tau mom sstar Avec_x Avec_y Avec_z Psi } "Synchronize" @@ -119,17 +120,19 @@ SCHEDULE AsterX_Con2Prim IN AsterX_Con2PrimGroup AFTER AsterX_ComputedBFromdBsta { LANG: C READS: ADMBaseX::metric(interior) - READS: dens(interior) tau(interior) mom(interior) dB(interior) + READS: dens(interior) tau(interior) sstar(interior) mom(interior) dB(interior) READS: saved_prims(interior) READS: Avec_x(interior) Avec_y(interior) Avec_z(interior) WRITES: con2prim_flag(interior) - WRITES: HydroBaseX::rho(interior) HydroBaseX::vel(interior) HydroBaseX::eps(interior) HydroBaseX::press(interior) HydroBaseX::Bvec(interior) + WRITES: HydroBaseX::rho(interior) HydroBaseX::vel(interior) HydroBaseX::eps(interior) HydroBaseX::press(interior) HydroBaseX::Bvec(interior) + WRITES: HydroBaseX::entropy(interior) WRITES: saved_prims(interior) - WRITES: dens(interior) tau(interior) mom(interior) dB(interior) + WRITES: dens(interior) tau(interior) sstar(interior) mom(interior) dB(interior) SYNC: con2prim_flag - SYNC: HydroBaseX::rho HydroBaseX::vel HydroBaseX::eps HydroBaseX::press HydroBaseX::Bvec + SYNC: HydroBaseX::rho HydroBaseX::vel HydroBaseX::eps HydroBaseX::press HydroBaseX::Bvec + SYNC: HydroBaseX::entropy SYNC: saved_prims - SYNC: dens tau mom dB + SYNC: dens tau sstar mom dB } "Calculate primitive variables from conservative variables" @@ -144,9 +147,10 @@ SCHEDULE AsterX_Fluxes IN AsterX_RHSGroup READS: ADMBaseX::metric(everywhere) READS: ADMBaseX::lapse(everywhere) READS: ADMBaseX::shift(everywhere) - READS: dens(everywhere) tau(everywhere) mom(everywhere) + READS: dens(everywhere) tau(everywhere) mom(everywhere) sstar(everywhere) READS: HydroBaseX::rho(everywhere) HydroBaseX::vel(everywhere) HydroBaseX::press(everywhere) HydroBaseX::eps(everywhere) READS: HydroBaseX::Bvec(everywhere) + READS: HydroBaseX::entropy(everywhere) READS: Avec_x(everywhere) Avec_y(everywhere) Avec_z(everywhere) Psi(everywhere) WRITES: flux_x(interior) flux_y(interior) flux_z(interior) WRITES: Aux_in_RHSof_A_Psi(interior) @@ -163,8 +167,8 @@ SCHEDULE AsterX_SourceTerms IN AsterX_RHSGroup AFTER AsterX_Fluxes READS: ADMBaseX::curv(everywhere) READS: HydroBaseX::rho(everywhere) HydroBaseX::vel(everywhere) HydroBaseX::press(everywhere) HydroBaseX::eps(everywhere) READS: HydroBaseX::Bvec(everywhere) - WRITES: densrhs(interior) taurhs(interior) momrhs(interior) - SYNC: densrhs taurhs momrhs + WRITES: densrhs(interior) taurhs(interior) momrhs(interior) sstarrhs(interior) + SYNC: densrhs taurhs momrhs sstarrhs } "Calculate the source terms and compute the RHS of the hydro equations" SCHEDULE AsterX_RHS IN AsterX_RHSGroup AFTER AsterX_SourceTerms @@ -172,12 +176,12 @@ SCHEDULE AsterX_RHS IN AsterX_RHSGroup AFTER AsterX_SourceTerms LANG: C READS: ADMBaseX::metric(everywhere) ADMBaseX::lapse(everywhere) ADMBaseX::shift(everywhere) READS: flux_x(everywhere) flux_y(everywhere) flux_z(everywhere) - READS: densrhs(everywhere) taurhs(everywhere) momrhs(everywhere) + READS: densrhs(everywhere) taurhs(everywhere) momrhs(everywhere) sstarrhs(everywhere) READS: Psi(everywhere) READS: Aux_in_RHSof_A_Psi(everywhere) - WRITES: densrhs(interior) taurhs(interior) momrhs(interior) + WRITES: densrhs(interior) taurhs(interior) momrhs(interior) sstarrhs(interior) WRITES: Avec_x_rhs(interior) Avec_y_rhs(interior) Avec_z_rhs(interior) Psi_rhs(interior) - SYNC: densrhs taurhs momrhs + SYNC: densrhs taurhs momrhs sstarrhs SYNC: Avec_x_rhs Avec_y_rhs Avec_z_rhs Psi_rhs } "Update the RHS of the hydro equations with the flux contributions" From ae022b35fefa9f2d34a9e771ab369cb47efe829a Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 9 Aug 2024 10:22:27 -0500 Subject: [PATCH 02/50] AsterX: Add entropy evolution - not tested --- AsterX/src/con2prim.cxx | 3 +++ AsterX/src/con2prim_rpa.cxx | 3 +++ AsterX/src/fluxes.cxx | 13 +++++++++++++ AsterX/src/prim2con.cxx | 2 ++ AsterX/src/rhs.cxx | 2 ++ AsterX/src/source.cxx | 1 + EntropyInitial/LICENSE | 25 +++++++++++++++++++++++++ EntropyInitial/configuration.ccl | 1 + EntropyInitial/interface.ccl | 6 ++++++ EntropyInitial/param.ccl | 1 + EntropyInitial/schedule.ccl | 9 +++++++++ EntropyInitial/src/SetEntropy.cxx | 29 +++++++++++++++++++++++++++++ EntropyInitial/src/make.code.defn | 1 + 13 files changed, 96 insertions(+) create mode 100644 EntropyInitial/LICENSE create mode 100644 EntropyInitial/configuration.ccl create mode 100644 EntropyInitial/interface.ccl create mode 100644 EntropyInitial/param.ccl create mode 100644 EntropyInitial/schedule.ccl create mode 100644 EntropyInitial/src/SetEntropy.cxx create mode 100644 EntropyInitial/src/make.code.defn diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index cd9d7b7f..938db053 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -117,6 +117,9 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, c2p_report rep_first; c2p_report rep_second; + // Invert entropy here + entropy(p.I) = sstar(p.I)/dens(p.I); + // Calling the first C2P switch (c2p_fir) { case c2p_first_t::Noble: { diff --git a/AsterX/src/con2prim_rpa.cxx b/AsterX/src/con2prim_rpa.cxx index 9e27ad17..4d76106c 100644 --- a/AsterX/src/con2prim_rpa.cxx +++ b/AsterX/src/con2prim_rpa.cxx @@ -84,6 +84,9 @@ extern "C" void AsterX_Con2Prim(CCTK_ARGUMENTS) { {momx(p.I), momy(p.I), momz(p.I)}, {dBx(p.I), dBy(p.I), dBz(p.I)}}; + // Invert entropy here + entropy(p.I) = sstar(p.I)/dens(p.I); + cv2pv(pv, cv, g, rep); // Handle incorrectable errors diff --git a/AsterX/src/fluxes.cxx b/AsterX/src/fluxes.cxx index 165bc325..adc964f4 100644 --- a/AsterX/src/fluxes.cxx +++ b/AsterX/src/fluxes.cxx @@ -36,6 +36,7 @@ void CalcFlux(CCTK_ARGUMENTS, EOSType &eos_th) { /* grid functions for fluxes */ const vec, dim> fluxdenss{fxdens, fydens, fzdens}; + const vec, dim> fluxsstars{fxsstar, fysstar, fzsstar}; const vec, dim> fluxmomxs{fxmomx, fymomx, fzmomx}; const vec, dim> fluxmomys{fxmomy, fymomy, fzmomy}; const vec, dim> fluxmomzs{fxmomz, fymomz, fzmomz}; @@ -168,6 +169,8 @@ void CalcFlux(CCTK_ARGUMENTS, EOSType &eos_th) { vec rho_rc{reconstruct_pt(rho, p, true, true)}; + vec entropy_rc{reconstruct_pt(entropy, p, true, true)}; + // set to atmo if reconstructed rho is less than atmo or is negative if (rho_rc(0) < rho_abs_min) { rho_rc(0) = rho_abs_min; @@ -276,6 +279,11 @@ void CalcFlux(CCTK_ARGUMENTS, EOSType &eos_th) { return sqrtg * rho_rc(f) * w_lorentz_rc(f); }); + /* sstar = sqrt(g) * D * s = sqrt(g) * (rho * W) * s */ + const vec sstar_rc([&](int f) ARITH_INLINE { + return sqrtg * rho_rc(f) * w_lorentz_rc(f) * entropy_rc(f); + }); + /* auxiliary: dens * h * W = sqrt(g) * rho * h * W^2 */ const vec dens_h_W_rc([&](int f) ARITH_INLINE { return dens_rc(f) * h_rc(f) * w_lorentz_rc(f); @@ -317,6 +325,10 @@ void CalcFlux(CCTK_ARGUMENTS, EOSType &eos_th) { const vec flux_dens( [&](int f) ARITH_INLINE { return dens_rc(f) * vtilde_rc(f); }); + /* flux(sstar) = sqrt(g) * D * s * vtilde^i = sqrt(g) * rho * W * s * vtilde^i */ + const vec flux_sstar( + [&](int f) ARITH_INLINE { return sstar_rc(f) * vtilde_rc(f); }); + /* flux(mom_j)^i = sqrt(g)*( * S_j*vtilde^i + alpha*((pgas+pmag)*delta^i_j - b_jB^i/W) ) */ const vec, 3> flux_moms([&](int j) ARITH_INLINE { @@ -353,6 +365,7 @@ void CalcFlux(CCTK_ARGUMENTS, EOSType &eos_th) { /* Calculate numerical fluxes */ fluxdenss(dir)(p.I) = calcflux(lambda, dens_rc, flux_dens); + fluxsstars(dir)(p.I) = calcflux(lambda, sstar_rc, flux_sstar); fluxmomxs(dir)(p.I) = calcflux(lambda, moms_rc(0), flux_moms(0)); fluxmomys(dir)(p.I) = calcflux(lambda, moms_rc(1), flux_moms(1)); fluxmomzs(dir)(p.I) = calcflux(lambda, moms_rc(2), flux_moms(2)); diff --git a/AsterX/src/prim2con.cxx b/AsterX/src/prim2con.cxx index 810f93df..cdd74226 100644 --- a/AsterX/src/prim2con.cxx +++ b/AsterX/src/prim2con.cxx @@ -45,6 +45,8 @@ extern "C" void AsterX_Prim2Con_Initial(CCTK_ARGUMENTS) { dBy(p.I) = cv.dBvec(1); dBz(p.I) = cv.dBvec(2); + sstar(p.I) = entropy(p.I)*cv.dens; + saved_rho(p.I) = pv.rho; saved_velx(p.I) = pv.vel(0); saved_vely(p.I) = pv.vel(1); diff --git a/AsterX/src/rhs.cxx b/AsterX/src/rhs.cxx index 7b36bb7f..4868c436 100644 --- a/AsterX/src/rhs.cxx +++ b/AsterX/src/rhs.cxx @@ -35,6 +35,7 @@ extern "C" void AsterX_RHS(CCTK_ARGUMENTS) { 1 / CCTK_DELTA_SPACE(2)}; const vec, dim> gf_fdens{fxdens, fydens, fzdens}; + const vec, dim> gf_fsstar{fxsstar, fysstar, fzsstar}; const vec, dim> gf_fmomx{fxmomx, fymomx, fzmomx}; const vec, dim> gf_fmomy{fxmomy, fymomy, fzmomy}; const vec, dim> gf_fmomz{fxmomz, fymomz, fzmomz}; @@ -81,6 +82,7 @@ extern "C" void AsterX_RHS(CCTK_ARGUMENTS) { grid.nghostzones, [=] CCTK_DEVICE(const PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE { densrhs(p.I) += calcupdate_hydro(gf_fdens, p); + sstarrhs(p.I) += calcupdate_hydro(gf_fsstar, p); momxrhs(p.I) += calcupdate_hydro(gf_fmomx, p); momyrhs(p.I) += calcupdate_hydro(gf_fmomy, p); momzrhs(p.I) += calcupdate_hydro(gf_fmomz, p); diff --git a/AsterX/src/source.cxx b/AsterX/src/source.cxx index 0b78e7ef..6c6944fd 100644 --- a/AsterX/src/source.cxx +++ b/AsterX/src/source.cxx @@ -137,6 +137,7 @@ template void SourceTerms(CCTK_ARGUMENTS) { /* Update the RHS grid functions */ densrhs(p.I) = 0.0; + sstarrhs(p.I) = 0.0; momxrhs(p.I) = alp_avg * sqrt_detg * mom_source(0); momyrhs(p.I) = alp_avg * sqrt_detg * mom_source(1); momzrhs(p.I) = alp_avg * sqrt_detg * mom_source(2); diff --git a/EntropyInitial/LICENSE b/EntropyInitial/LICENSE new file mode 100644 index 00000000..846c6426 --- /dev/null +++ b/EntropyInitial/LICENSE @@ -0,0 +1,25 @@ +BSD 2-Clause License + +Copyright (c) 2019, Zachariah Etienne +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/EntropyInitial/configuration.ccl b/EntropyInitial/configuration.ccl new file mode 100644 index 00000000..1f778d56 --- /dev/null +++ b/EntropyInitial/configuration.ccl @@ -0,0 +1 @@ +REQUIRES Loop diff --git a/EntropyInitial/interface.ccl b/EntropyInitial/interface.ccl new file mode 100644 index 00000000..c572b569 --- /dev/null +++ b/EntropyInitial/interface.ccl @@ -0,0 +1,6 @@ +IMPLEMENTS: EntropyInitial + +INHERITS: ADMBaseX CarpetX HydroBaseX AsterX + +USES INCLUDE HEADER: fixmath.hxx +USES INCLUDE HEADER: loop_device.hxx diff --git a/EntropyInitial/param.ccl b/EntropyInitial/param.ccl new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/EntropyInitial/param.ccl @@ -0,0 +1 @@ + diff --git a/EntropyInitial/schedule.ccl b/EntropyInitial/schedule.ccl new file mode 100644 index 00000000..0baaf9ea --- /dev/null +++ b/EntropyInitial/schedule.ccl @@ -0,0 +1,9 @@ + +schedule SetEntropy IN HydroBaseX_PostInitial +{ + LANG: C + + READS: HydroBaseX::rho(everywhere) HydroBaseX::eps(everywhere) HydroBaseX::press(everywhere) + WRITES: HydroBaseX::entropy(everywhere) + +} "Set initial entropy" diff --git a/EntropyInitial/src/SetEntropy.cxx b/EntropyInitial/src/SetEntropy.cxx new file mode 100644 index 00000000..15a705d8 --- /dev/null +++ b/EntropyInitial/src/SetEntropy.cxx @@ -0,0 +1,29 @@ +#include +#include + +#include +#include +#include + +#include +#include +#include + +extern "C" void SetEntropy(CCTK_ARGUMENTS) +{ + + DECLARE_CCTK_ARGUMENTSX_SetEntropy; + DECLARE_CCTK_PARAMETERS; + + CCTK_VINFO("Set the entropy!"); + + grid.loop_all_device<1, 1, 1>( + grid.nghostzones, + [=] CCTK_DEVICE(const Loop::PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE { + + entropy(p.I) = press(p.I)/rho(p.I); + + }); +} + + diff --git a/EntropyInitial/src/make.code.defn b/EntropyInitial/src/make.code.defn new file mode 100644 index 00000000..ff556b89 --- /dev/null +++ b/EntropyInitial/src/make.code.defn @@ -0,0 +1 @@ +SRCS = SetEntropy.cxx From ba075e9c7c4c634172f12a094b4142b912a35e52 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Sat, 10 Aug 2024 16:54:52 -0500 Subject: [PATCH 03/50] Con2PrimFactory: Start implementing entropy inversion based on Palenzuela --- Con2PrimFactory/src/c2p_1DEntropy.hxx | 411 ++++++++++++++++++++++++++ 1 file changed, 411 insertions(+) create mode 100644 Con2PrimFactory/src/c2p_1DEntropy.hxx diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx new file mode 100644 index 00000000..cd955360 --- /dev/null +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -0,0 +1,411 @@ +#ifndef C2P_1DENTROPY_HXX +#define C2P_1DENTROPY_HXX + +#include "c2p.hxx" +#include "roots.hxx" +namespace Con2PrimFactory { + +class c2p_1DEntropy : public c2p { +public: + /* Some attributes */ + CCTK_REAL GammaIdealFluid; + + /* Constructor */ + template + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy( + EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len); + + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL + get_Ssq_Exact(vec &mom, + const smat &gup) const; + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL + get_Bsq_Exact(vec &B_up, + const smat &glo) const; + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL + get_BiSi_Exact(vec &Bvec, vec &mom) const; + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec + get_WLorentz_vsq_bsq_Seeds(vec &B_up, + vec &v_up, + const smat &glo) const; + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void + set_to_nan(prim_vars &pv, cons_vars &cv) const; + /* Called by 1DEntropy */ + template + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void + xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, CCTK_REAL Bsq, + CCTK_REAL BiSi, EOSType &eos_th, prim_vars &pv, + cons_vars cv, const smat &gup, + const smat &glo) const; + + template + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL + funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, + CCTK_REAL x, EOSType &eos_th, cons_vars &cv) const; + + template + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void + solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cons_vars cv, + const smat &glo, c2p_report &rep) const; + + /* Destructor */ + CCTK_HOST CCTK_DEVICE ~c2p_1DEntropy(); +}; + +/* Constructor */ +template +CCTK_HOST CCTK_DEVICE + CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( + EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len) { + + GammaIdealFluid = eos_th.gamma; + maxIterations = maxIter; + tolerance = tol; + rho_strict = rho_str; + ye_lenient = ye_len; + vw_lim = vwlim; + w_lim = sqrt(1.0 + vw_lim * vw_lim); + v_lim = vw_lim / w_lim; + Bsq_lim = B_lim * B_lim; + atmo = atm; +} + +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL +c2p_1DEntropy::get_Ssq_Exact(vec &mom, + const smat &gup) const { + + CCTK_REAL Ssq; + /* calculate S_squared */ + Ssq = mom(X) * (gup(X, X) * mom(X) + gup(X, Y) * mom(Y) + gup(X, Z) * mom(Z)); + Ssq += + mom(Y) * (gup(X, Y) * mom(X) + gup(Y, Y) * mom(Y) + gup(Y, Z) * mom(Z)); + Ssq += + mom(Z) * (gup(X, Z) * mom(X) + gup(Y, Z) * mom(Y) + gup(Z, Z) * mom(Z)); + + if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { + Ssq = fabs(Ssq); + } + return Ssq; +} + +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL +c2p_1DEntropy::get_Bsq_Exact(vec &B_up, + const smat &glo) const { + + vec B_low = calc_contraction(glo, B_up); + return calc_contraction(B_low, B_up); // Bsq +} + +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL +c2p_1DEntropy::get_BiSi_Exact(vec &Bvec, + vec &mom) const { + + return Bvec(X) * mom(X) + Bvec(Y) * mom(Y) + Bvec(Z) * mom(Z); // BiSi +} + +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec +c2p_1DEntropy::get_WLorentz_vsq_bsq_Seeds( + vec &B_up, vec &v_up, + const smat &glo) const { + vec v_low = calc_contraction(glo, v_up); + CCTK_REAL vsq = calc_contraction(v_low, v_up); + CCTK_REAL VdotB = calc_contraction(v_low, B_up); + CCTK_REAL VdotBsq = VdotB * VdotB; + CCTK_REAL Bsq = get_Bsq_Exact(B_up, glo); + + if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { + vsq = fabs(vsq); + } + + CCTK_REAL w_lor = 1. / sqrt(1. - vsq); + CCTK_REAL bsq = ((Bsq) / (w_lor * w_lor)) + VdotBsq; + vec w_vsq_bsq{w_lor, vsq, bsq}; + + return w_vsq_bsq; //{w_lor, vsq, bsq} +} + +/* Called by 1DEntropy */ + +template +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void +c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, + CCTK_REAL Bsq, CCTK_REAL BiSi, + EOSType &eos_th, prim_vars &pv, + cons_vars cv, const smat &gup, + const smat &glo) const { + const CCTK_REAL qPalenzuela = cv.tau / cv.dens; + const CCTK_REAL rPalenzuela = Ssq / pow(cv.dens, 2); + const CCTK_REAL sPalenzuela = Bsq / cv.dens; + const CCTK_REAL tPalenzuela = BiSi / pow(cv.dens, 3. / 2.); + + // (i) + CCTK_REAL Wminus2 = + 1.0 - + (xPalenzuela_Sol * xPalenzuela_Sol * rPalenzuela + + (2.0 * xPalenzuela_Sol + sPalenzuela) * tPalenzuela * tPalenzuela) / + (xPalenzuela_Sol * xPalenzuela_Sol * (xPalenzuela_Sol + sPalenzuela) * + (xPalenzuela_Sol + sPalenzuela)); + Wminus2 = fmin(fmax(Wminus2, 1e-10), 1 - 1e-10); + const CCTK_REAL W_sol = pow(Wminus2, -0.5); + + // (ii) + pv.rho = cv.dens / W_sol; + + // (iii) + pv.eps = W_sol - 1.0 + (1.0 - W_sol * W_sol) * xPalenzuela_Sol / W_sol + + W_sol * (qPalenzuela - sPalenzuela + + tPalenzuela * tPalenzuela / + (2 * xPalenzuela_Sol * xPalenzuela_Sol) + + sPalenzuela / (2.0 * W_sol * W_sol)); + + // (iv) + // CCTK_REAL P_loc = get_Press_funcRhoEps(rho_loc, eps_loc); + + // Taken from WZ2Prim (2DNRNoble) + CCTK_REAL Z_Sol = xPalenzuela_Sol * pv.rho * W_sol; + + pv.vel(X) = + (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(X) += BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); + + pv.vel(Y) = + (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(Y) += BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); + + pv.vel(Z) = + (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(Z) += BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); + + pv.w_lor = W_sol; + + pv.Ye = cv.dYe / cv.dens; + + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + + pv.Bvec = cv.dBvec; + + const vec Elow = calc_cross_product(pv.Bvec, pv.vel); + pv.E = calc_contraction(gup, Elow); +} + +template +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL +c2p_1DPalenzuela::funcRoot_1DPalenzuela(CCTK_REAL Ssq, CCTK_REAL Bsq, + CCTK_REAL BiSi, CCTK_REAL x, + EOSType &eos_th, cons_vars &cv) const { + // computes f(x) from x and q,r,s,t + const CCTK_REAL qPalenzuela = cv.tau / cv.dens; + const CCTK_REAL rPalenzuela = Ssq / pow(cv.dens, 2); + const CCTK_REAL sPalenzuela = Bsq / cv.dens; + const CCTK_REAL tPalenzuela = BiSi / pow(cv.dens, 3. / 2.); + + // (i) + CCTK_REAL Wminus2 = + 1.0 - (x * x * rPalenzuela + + (2.0 * x + sPalenzuela) * tPalenzuela * tPalenzuela) / + (x * x * (x + sPalenzuela) * (x + sPalenzuela)); + Wminus2 = fmin(fmax(Wminus2, 1e-10), 1 - 1e-10); + const CCTK_REAL W_loc = pow(Wminus2, -0.5); + + // (ii) + CCTK_REAL rho_loc = cv.dens / W_loc; + CCTK_REAL Ye_loc = cv.dYe / cv.dens; + + // (iii) + CCTK_REAL eps_loc = W_loc - 1.0 + (1.0 - W_loc * W_loc) * x / W_loc + + W_loc * (qPalenzuela - sPalenzuela + + tPalenzuela * tPalenzuela / (2 * x * x) + + sPalenzuela / (2 * W_loc * W_loc)); + + // (iv) + CCTK_REAL P_loc = + eos_th.press_from_valid_rho_eps_ye(rho_loc, eps_loc, Ye_loc); + + return (x - (1.0 + eps_loc + P_loc / rho_loc) * W_loc); +} + +template +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void +c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, + cons_vars cv, const smat &glo, + c2p_report &rep) const { + + ROOTSTAT status = ROOTSTAT::SUCCESS; + rep.iters = 0; + rep.adjust_cons = false; + rep.set_atmo = false; + rep.status = c2p_report::SUCCESS; + + /* Check validity of the 3-metric and compute its inverse */ + const CCTK_REAL spatial_detg = calc_det(glo); + const CCTK_REAL sqrt_detg = sqrt(spatial_detg); + if ((!isfinite(sqrt_detg)) || (sqrt_detg <= 0)) { + rep.set_invalid_detg(sqrt_detg); + set_to_nan(pv, cv); + return; + } + const smat gup = calc_inv(glo, spatial_detg); + + /* Undensitize the conserved vars */ + cv.dens /= sqrt_detg; + cv.tau /= sqrt_detg; + cv.mom /= sqrt_detg; + cv.dBvec /= sqrt_detg; + cv.dYe /= sqrt_detg; + + if (cv.dens <= atmo.rho_cut) { + rep.set_atmo_set(); + atmo.set(pv, cv, glo); + return; + } + + // compute primitive B seed from conserved B of current time step for better + // guess + pv_seeds.Bvec = cv.dBvec; + + const CCTK_REAL Ssq = get_Ssq_Exact(cv.mom, gup); + const CCTK_REAL Bsq = get_Bsq_Exact(pv_seeds.Bvec, glo); + const CCTK_REAL BiSi = get_BiSi_Exact(pv_seeds.Bvec, cv.mom); + const vec w_vsq_bsq = get_WLorentz_vsq_bsq_Seeds( + pv_seeds.Bvec, pv_seeds.vel, glo); // this also recomputes pv_seeds.w_lor + pv_seeds.w_lor = w_vsq_bsq(0); + // CCTK_REAL vsq_seed = w_vsq_bsq(1); + // const CCTK_REAL bsq = w_vsq_bsq(2); + + if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || + (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { + rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); + set_to_nan(pv, cv); + return; + } + + if (Bsq < 0) { + rep.set_neg_Bsq(Bsq); + set_to_nan(pv, cv); + return; + } + + if (Bsq > Bsq_lim) { + rep.set_B_limit(Bsq); + set_to_nan(pv, cv); + return; + } + + /* update rho seed from cv and wlor */ + // rho consistent with cv.rho should be better guess than rho from last + // timestep + pv_seeds.rho = cv.dens / pv_seeds.w_lor; + + // Find x, this is the recovery process + const CCTK_INT minbits = std::numeric_limits::digits - 4; + const CCTK_INT maxiters = maxIterations; + + CCTK_REAL qPalenzuela = cv.tau / cv.dens; + CCTK_REAL sPalenzuela = Bsq / cv.dens; + CCTK_REAL xPalenzuela_lowerBound = 1.0 + qPalenzuela - sPalenzuela; + CCTK_REAL xPalenzuela_upperBound = 2.0 + 2.0 * qPalenzuela - sPalenzuela; + CCTK_REAL a = xPalenzuela_lowerBound; + CCTK_REAL b = xPalenzuela_upperBound; + auto fn = [&](auto x) { + return funcRoot_1DPalenzuela(Ssq, Bsq, BiSi, x, eos_th, cv); + }; + auto result = Algo::brent(fn, a, b, minbits, maxiters, rep.iters); + + // Pick best solution + CCTK_REAL xPalenzuela_Sol; + if (abs(fn(result.first)) < abs(fn(result.second))) { + xPalenzuela_Sol = result.first; + } else { + xPalenzuela_Sol = result.second; + } + + // Check solution and calculate primitives + // TODO:check if to pass result.first or xPalenzuela_Sol + if (rep.iters < maxiters && abs(fn(xPalenzuela_Sol)) < tolerance) { + rep.status = c2p_report::SUCCESS; + status = ROOTSTAT::SUCCESS; + } else { + // set status to root not converged + rep.set_root_conv(); + status = ROOTSTAT::NOT_CONVERGED; + } + + xPalenzuelaToPrim(xPalenzuela_Sol, Ssq, Bsq, BiSi, eos_th, pv, cv, gup, glo); + + // set to atmo if computed rho is below floor density + if (pv.rho < atmo.rho_cut) { + rep.set_atmo_set(); + atmo.set(pv, cv, glo); + return; + } + + // check the validity of the computed eps + auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); + if (pv.eps > rgeps.max) { + //printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); + rep.adjust_cons = true; + if (pv.rho >= rho_strict) { + rep.set_range_eps(pv.eps); // sets adjust_cons to false by default + rep.adjust_cons = true; + set_to_nan(pv, cv); + return; + } + } else if (pv.eps < rgeps.min) { + /* + printf( + "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e \n", + pv.eps, rgeps.min); + printf(" Not adjusting cons.. \n"); + */ + rep.set_range_eps(rgeps.min); // sets adjust_cons to true + } + + // TODO: check validity for Ye + + // check if computed velocities are within the specified limit + vec v_low = calc_contraction(glo, pv.vel); + CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); + CCTK_REAL sol_v = sqrt(vsq_Sol); + if (sol_v > v_lim) { + /* + printf("(sol_v > v_lim) is true! \n"); + printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); + */ + pv.rho = cv.dens / w_lim; + if (pv.rho >= rho_strict) { + rep.set_speed_limit({sol_v, sol_v, sol_v}); + set_to_nan(pv, cv); + return; + } + pv.vel *= v_lim / sol_v; + pv.w_lor = w_lim; + pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), eos_th.rgeps.max); + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + + rep.adjust_cons = true; + } + + // Recompute cons if prims have been adjusted + if (rep.adjust_cons) { + cv.from_prim(pv, glo); + } +} + +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void +c2p_1DPalenzuela::set_to_nan(prim_vars &pv, cons_vars &cv) const { + pv.set_to_nan(); + cv.set_to_nan(); +} + +/* Destructor */ +CCTK_HOST CCTK_DEVICE + CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::~c2p_1DPalenzuela() { + // How to destruct properly a vector? +} +} // namespace Con2PrimFactory + +#endif From 745eee58189efbc8c90421f6c256a1c402f2c646 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Wed, 14 Aug 2024 16:58:49 -0500 Subject: [PATCH 04/50] Con2PrimFactory: Minimal change --- Con2PrimFactory/src/c2p_1DEntropy.hxx | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index cd955360..828f9d22 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -192,16 +192,24 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, pv.E = calc_contraction(gup, Elow); } +// See Appendix A.4 of https://arxiv.org/pdf/1112.0568 template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_1DPalenzuela::funcRoot_1DPalenzuela(CCTK_REAL Ssq, CCTK_REAL Bsq, - CCTK_REAL BiSi, CCTK_REAL x, - EOSType &eos_th, cons_vars &cv) const { - // computes f(x) from x and q,r,s,t - const CCTK_REAL qPalenzuela = cv.tau / cv.dens; - const CCTK_REAL rPalenzuela = Ssq / pow(cv.dens, 2); - const CCTK_REAL sPalenzuela = Bsq / cv.dens; - const CCTK_REAL tPalenzuela = BiSi / pow(cv.dens, 3. / 2.); +c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, + CCTK_REAL BiSi, CCTK_REAL rho, + EOSType &eos_th, CCTK_REAL dens, + CCTK_REAL sstar) const { + + // dens and sstar are undensitized + // i.e. we already divided by sqrt(gamma) + + const CCTK_REAL ent = sstar/dens; + + // Compute h_{cold} but using entropy + + const CCTK_REAL P_loc = + eos_th.press_from_valid_rho_entropy_ye(rho_loc, eps_loc, Ye_loc); + // (i) CCTK_REAL Wminus2 = @@ -222,8 +230,6 @@ c2p_1DPalenzuela::funcRoot_1DPalenzuela(CCTK_REAL Ssq, CCTK_REAL Bsq, sPalenzuela / (2 * W_loc * W_loc)); // (iv) - CCTK_REAL P_loc = - eos_th.press_from_valid_rho_eps_ye(rho_loc, eps_loc, Ye_loc); return (x - (1.0 + eps_loc + P_loc / rho_loc) * W_loc); } From 85ffd8dd3d42907ed056d448aa2b0991c39461d0 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 15 Aug 2024 09:37:46 -0500 Subject: [PATCH 05/50] Con2PrimFactory: Add master function for entropy inversion --- Con2PrimFactory/src/c2p_1DEntropy.hxx | 47 ++++++++++++--------------- 1 file changed, 21 insertions(+), 26 deletions(-) diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 828f9d22..b2766871 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -196,42 +196,37 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, - CCTK_REAL BiSi, CCTK_REAL rho, + CCTK_REAL BiSi, CCTK_REAL x, EOSType &eos_th, CCTK_REAL dens, - CCTK_REAL sstar) const { + CCTK_REAL sstar, CCTK_REAL dYe) const { - // dens and sstar are undensitized - // i.e. we already divided by sqrt(gamma) + // We already divided dens, sstar and + // dYe by sqrt(gamma) - const CCTK_REAL ent = sstar/dens; + const CCTK_REAL ent_loc = sstar/dens; + const CCTK_REAL ye_loc = dYe/dens; // Compute h_{cold} but using entropy + const CCTK_REAL press_loc = + eos_th.press_from_valid_rho_entropy_ye(x, ent_loc, ye_loc); - const CCTK_REAL P_loc = - eos_th.press_from_valid_rho_entropy_ye(rho_loc, eps_loc, Ye_loc); + const CCTK_REAL eps_loc = + eos_th.eps_from_valid_rho_entropy_ye(x, ent_loc, ye_loc); + // Compute (A60) using + // W = rho*h*lorentz*lorentz + const CCTK_REAL lor_loc = dens/x; + const CCTK_REAL h_loc = (1.0+eps_loc+press/x); + const CCTK_REAL W = x*h_loc*lor_loc*lor_loc; - // (i) - CCTK_REAL Wminus2 = - 1.0 - (x * x * rPalenzuela + - (2.0 * x + sPalenzuela) * tPalenzuela * tPalenzuela) / - (x * x * (x + sPalenzuela) * (x + sPalenzuela)); - Wminus2 = fmin(fmax(Wminus2, 1e-10), 1 - 1e-10); - const CCTK_REAL W_loc = pow(Wminus2, -0.5); - - // (ii) - CCTK_REAL rho_loc = cv.dens / W_loc; - CCTK_REAL Ye_loc = cv.dYe / cv.dens; - - // (iii) - CCTK_REAL eps_loc = W_loc - 1.0 + (1.0 - W_loc * W_loc) * x / W_loc + - W_loc * (qPalenzuela - sPalenzuela + - tPalenzuela * tPalenzuela / (2 * x * x) + - sPalenzuela / (2 * W_loc * W_loc)); + // Compute (A61) + const CCTK_REAL Sfsq = (W*W*Ssq+BiSi*BiSi*(Bsq+2.0*W))/ + ((W+Bsq)*(W+Bsq)); - // (iv) + // Compute (A62) + const CCTK_REAL rho = dens/sqrt(1.0+Sfsq/(dens*dens*h_loc*h_loc)); - return (x - (1.0 + eps_loc + P_loc / rho_loc) * W_loc); + return x-rho; } template From 2a8658916d83eb53602c119906aedddb39fb507a Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 15 Aug 2024 10:04:56 -0500 Subject: [PATCH 06/50] Con2PrimFactory: Modify solve function --- Con2PrimFactory/src/c2p_1DEntropy.hxx | 32 +++++++++++++-------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index b2766871..0adf03b3 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -231,9 +231,9 @@ c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void -c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, - cons_vars cv, const smat &glo, - c2p_report &rep) const { +c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, + cons_vars cv, CCTK_REAL sstar, + const smat &glo, c2p_report &rep) const { ROOTSTAT status = ROOTSTAT::SUCCESS; rep.iters = 0; @@ -257,6 +257,7 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cv.mom /= sqrt_detg; cv.dBvec /= sqrt_detg; cv.dYe /= sqrt_detg; + sstar /= sqrt_detg; if (cv.dens <= atmo.rho_cut) { rep.set_atmo_set(); @@ -305,28 +306,27 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, const CCTK_INT minbits = std::numeric_limits::digits - 4; const CCTK_INT maxiters = maxIterations; - CCTK_REAL qPalenzuela = cv.tau / cv.dens; - CCTK_REAL sPalenzuela = Bsq / cv.dens; - CCTK_REAL xPalenzuela_lowerBound = 1.0 + qPalenzuela - sPalenzuela; - CCTK_REAL xPalenzuela_upperBound = 2.0 + 2.0 * qPalenzuela - sPalenzuela; - CCTK_REAL a = xPalenzuela_lowerBound; - CCTK_REAL b = xPalenzuela_upperBound; + // See Appendix A.4 of https://arxiv.org/pdf/1112.0568 + // Compute (A59) + CCTK_REAL a = cv.dens/sqrt(1.0+Ssq/(cv.dens*cv.dens)); + CCTK_REAL b = cv.dens; auto fn = [&](auto x) { - return funcRoot_1DPalenzuela(Ssq, Bsq, BiSi, x, eos_th, cv); + return funcRoot_1DEntropy(Ssq, Bsq, BiSi, x, eos_th, + cv.dens, sstar, cv.dYe); }; auto result = Algo::brent(fn, a, b, minbits, maxiters, rep.iters); // Pick best solution - CCTK_REAL xPalenzuela_Sol; + CCTK_REAL xEntropy_Sol; if (abs(fn(result.first)) < abs(fn(result.second))) { - xPalenzuela_Sol = result.first; + xEntropy_Sol = result.first; } else { - xPalenzuela_Sol = result.second; + xEntropy_Sol = result.second; } // Check solution and calculate primitives - // TODO:check if to pass result.first or xPalenzuela_Sol - if (rep.iters < maxiters && abs(fn(xPalenzuela_Sol)) < tolerance) { + // TODO:check if to pass result.first or xEntropy_Sol + if (rep.iters < maxiters && abs(fn(xEntropy_Sol)) < tolerance) { rep.status = c2p_report::SUCCESS; status = ROOTSTAT::SUCCESS; } else { @@ -335,7 +335,7 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, status = ROOTSTAT::NOT_CONVERGED; } - xPalenzuelaToPrim(xPalenzuela_Sol, Ssq, Bsq, BiSi, eos_th, pv, cv, gup, glo); + xEntropyToPrim(xEntropy_Sol, Ssq, Bsq, BiSi, eos_th, pv, cv, gup, glo); // set to atmo if computed rho is below floor density if (pv.rho < atmo.rho_cut) { From e8028e31b0aaa4d5ba30ec92459ca11e446f31d4 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 23 Aug 2024 12:01:50 -0500 Subject: [PATCH 07/50] Con2PrimFactory: Include entropy as prim and cons --- Con2PrimFactory/src/atmo.hxx | 8 ++++++-- Con2PrimFactory/src/c2p_1DEntropy.hxx | 10 +++------- Con2PrimFactory/src/c2p_report.hxx | 15 +++++++++++++++ Con2PrimFactory/src/cons.hxx | 11 +++++++---- Con2PrimFactory/src/prims.hxx | 10 ++++++---- 5 files changed, 37 insertions(+), 17 deletions(-) diff --git a/Con2PrimFactory/src/atmo.hxx b/Con2PrimFactory/src/atmo.hxx index 95d38e18..dc894efb 100644 --- a/Con2PrimFactory/src/atmo.hxx +++ b/Con2PrimFactory/src/atmo.hxx @@ -16,15 +16,16 @@ struct atmosphere { CCTK_REAL eps_atmo; CCTK_REAL ye_atmo; CCTK_REAL press_atmo; + CCTK_REAL entropy_atmo; CCTK_REAL rho_cut; CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline atmosphere() = default; CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline atmosphere( - CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL Ye_, CCTK_REAL press_, + CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL Ye_, CCTK_REAL press_, CCTK_REAL entropy_, CCTK_REAL rho_cut_) - : rho_atmo(rho_), eps_atmo(eps_), ye_atmo(Ye_), press_atmo(press_), + : rho_atmo(rho_), eps_atmo(eps_), ye_atmo(Ye_), press_atmo(press_), entropy_atmo(entropy_), rho_cut(rho_cut_) {} CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline atmosphere & @@ -36,6 +37,7 @@ struct atmosphere { eps_atmo = other.eps_atmo; ye_atmo = other.ye_atmo; press_atmo = other.press_atmo; + entropy_atmo = other.entropy_atmo; rho_cut = other.rho_cut; return *this; } @@ -47,6 +49,7 @@ struct atmosphere { pv.eps = eps_atmo; pv.Ye = ye_atmo; pv.press = press_atmo; + pv.entropy = entropy_atmo; pv.vel(0) = 0.0; pv.vel(1) = 0.0; pv.vel(2) = 0.0; @@ -66,6 +69,7 @@ struct atmosphere { cv.mom(1) = 0.0; cv.mom(2) = 0.0; cv.dYe = cv.dens * ye_atmo; + cv.dS = cv.dens * entropy_atmo; const vec &B_up = pv.Bvec; const vec B_low = calc_contraction(g, B_up); CCTK_REAL Bsq = calc_contraction(B_up, B_low); diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 0adf03b3..15dfe6c7 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -262,6 +262,7 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, if (cv.dens <= atmo.rho_cut) { rep.set_atmo_set(); atmo.set(pv, cv, glo); + eos_th.entropy_from_valid_rho_eps_ye(x,pv.eps,pv.Ye); return; } @@ -316,13 +317,7 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, }; auto result = Algo::brent(fn, a, b, minbits, maxiters, rep.iters); - // Pick best solution - CCTK_REAL xEntropy_Sol; - if (abs(fn(result.first)) < abs(fn(result.second))) { - xEntropy_Sol = result.first; - } else { - xEntropy_Sol = result.second; - } + CCTK_REAL xEntropy_Sol = 0.5*(result.first+result.second); // Check solution and calculate primitives // TODO:check if to pass result.first or xEntropy_Sol @@ -341,6 +336,7 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, if (pv.rho < atmo.rho_cut) { rep.set_atmo_set(); atmo.set(pv, cv, glo); + eos_th.entropy_from_valid_rho_temp_ye(x,,); return; } diff --git a/Con2PrimFactory/src/c2p_report.hxx b/Con2PrimFactory/src/c2p_report.hxx index b7225b24..ec954e25 100644 --- a/Con2PrimFactory/src/c2p_report.hxx +++ b/Con2PrimFactory/src/c2p_report.hxx @@ -22,6 +22,7 @@ public: NANS_IN_CONS, ///< One or more evolved variables is NAN/INF RANGE_RHO, ///< Mass density outside EOS range RANGE_EPS, ///< Fluid internal energy outside EOS range + RANGE_ENT, ///< Evolved entropy outside EOS range SPEED_LIMIT, ///< Speed limit exceeded RANGE_YE, ///< Electron fraction outside EOS range B_LIMIT, ///< Magnetization above limit @@ -93,6 +94,9 @@ private: /// Specific internal energy \f$ \epsilon \f$. CCTK_REAL eps; + /// Entropy + CCTK_REAL entropy; + /// Velocity. vec vel; @@ -153,6 +157,14 @@ public: eps = eps_; } + CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline void + set_range_entropy(CCTK_REAL entropy_) { + status = RANGE_ENT; + set_atmo = false; + adjust_cons = true; // we adjust cons in this case! + entropy = entropy_; + } + CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_speed_limit(vec vel_) { status = SPEED_LIMIT; @@ -235,6 +247,9 @@ public: case RANGE_EPS: printf("Specific energy was out of range! eps readjusted to = %16.8e \n", eps); break; + case RANGE_ENT: + printf("Evolved entropy was out of range! entropy readjusted to = %16.8e \n", entropy); + break; case SPEED_LIMIT: printf("Speed limit exceeded, vx, vy, vz = %16.8e, %16.8e, %16.8e \n", vel(0), vel(1), vel(2)); diff --git a/Con2PrimFactory/src/cons.hxx b/Con2PrimFactory/src/cons.hxx index 43a6118f..cbeb17c3 100644 --- a/Con2PrimFactory/src/cons.hxx +++ b/Con2PrimFactory/src/cons.hxx @@ -15,6 +15,7 @@ struct cons_vars { vec mom; CCTK_REAL tau; CCTK_REAL dYe; + CCTK_REAL dS; vec dBvec; // Default constructor, no initialization. @@ -22,9 +23,9 @@ struct cons_vars { // Construct from single variables. CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline cons_vars( - CCTK_REAL dens_, vec mom_, CCTK_REAL tau_, CCTK_REAL dYe_, + CCTK_REAL dens_, vec mom_, CCTK_REAL tau_, CCTK_REAL dYe_, CCTK_REAL dS_, vec dBvec_) - : dens{dens_}, mom{mom_}, tau{tau_}, dYe{dYe_}, dBvec{dBvec_} {} + : dens{dens_}, mom{mom_}, tau{tau_}, dYe{dYe_}, dS{dS_}, dBvec{dBvec_} {} CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline void from_prim(const prim_vars &pv, const smat &g) { @@ -66,11 +67,12 @@ struct cons_vars { dBvec = sqrt_detg * pv.Bvec; dYe = dens * pv.Ye; + dS = dens * pv.entropy; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void scatter(CCTK_REAL &dens_, CCTK_REAL &momx_, CCTK_REAL &momy_, - CCTK_REAL &momz_, CCTK_REAL &tau_, CCTK_REAL &dYe_, + CCTK_REAL &momz_, CCTK_REAL &tau_, CCTK_REAL &dYe_, CCTK_REAL &dS_, CCTK_REAL &dBvecx_, CCTK_REAL &dBvecy_, CCTK_REAL &dBvecz_) const { dens_ = dens; @@ -79,13 +81,14 @@ struct cons_vars { momz_ = mom(2); tau_ = tau; dYe_ = dYe; + dS_ = dS; dBvecx_ = dBvec(0); dBvecy_ = dBvec(1); dBvecz_ = dBvec(2); } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan() { - dens = mom(0) = mom(1) = mom(2) = tau = dYe = dBvec(0) = dBvec(1) = + dens = mom(0) = mom(1) = mom(2) = tau = dYe = dS = dBvec(0) = dBvec(1) = dBvec(2) = std::numeric_limits::quiet_NaN(); } }; diff --git a/Con2PrimFactory/src/prims.hxx b/Con2PrimFactory/src/prims.hxx index 6f4458b0..6c02ad78 100644 --- a/Con2PrimFactory/src/prims.hxx +++ b/Con2PrimFactory/src/prims.hxx @@ -14,6 +14,7 @@ struct prim_vars { CCTK_REAL eps; CCTK_REAL Ye; CCTK_REAL press; + CCTK_REAL entropy; vec vel; CCTK_REAL w_lor; vec Bvec; @@ -24,13 +25,13 @@ struct prim_vars { /// Construct from single variables. CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline prim_vars( - CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL ye_, CCTK_REAL press_, + CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL ye_, CCTK_REAL press_, CCTK_REAL entropy_, vec vel_, CCTK_REAL w_lor_, vec Bvec_) - : rho(rho_), eps(eps_), Ye(ye_), press(press_), vel(vel_), w_lor(w_lor_), + : rho(rho_), eps(eps_), Ye(ye_), press(press_), entropy(entropy_), vel(vel_), w_lor(w_lor_), Bvec(Bvec_){}; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void - scatter(CCTK_REAL &rho_, CCTK_REAL &eps_, CCTK_REAL &ye_, CCTK_REAL &press_, + scatter(CCTK_REAL &rho_, CCTK_REAL &eps_, CCTK_REAL &ye_, CCTK_REAL &press_, CCTK_REAL &entropy_, CCTK_REAL &velx_, CCTK_REAL &vely_, CCTK_REAL &velz_, CCTK_REAL &w_lor_, CCTK_REAL &Bvec_x_, CCTK_REAL &Bvec_y_, CCTK_REAL &Bvec_z_, CCTK_REAL &E_x_, CCTK_REAL &E_y_, @@ -39,6 +40,7 @@ struct prim_vars { eps_ = eps; ye_ = Ye; press_ = press; + entropy_ = entropy; velx_ = vel(0); vely_ = vel(1); velz_ = vel(2); @@ -52,7 +54,7 @@ struct prim_vars { } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan() { - rho = eps = Ye = press = vel(0) = vel(1) = vel(2) = w_lor = Bvec(0) = + rho = eps = Ye = press = entropy = vel(0) = vel(1) = vel(2) = w_lor = Bvec(0) = Bvec(1) = Bvec(2) = E(0) = E(1) = E(2) = std::numeric_limits::quiet_NaN(); } From 16cd18c5febc65193d5479bfe73aae6b8fc14720 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 23 Aug 2024 22:00:45 -0500 Subject: [PATCH 08/50] Con2PrimFactory: First draft of entropy inversion file --- Con2PrimFactory/src/c2p_1DEntropy.hxx | 313 ++++++++++++++------------ 1 file changed, 175 insertions(+), 138 deletions(-) diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 15dfe6c7..fb995da5 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -17,31 +17,28 @@ public: CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Ssq_Exact(vec &mom, - const smat &gup) const; + get_Ssq_Exact(vec &mom, const smat &gup) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Bsq_Exact(vec &B_up, - const smat &glo) const; + get_Bsq_Exact(vec &B_up, const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_BiSi_Exact(vec &Bvec, vec &mom) const; + get_BiSi_Exact(vec &Bvec, vec &mom) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec - get_WLorentz_vsq_bsq_Seeds(vec &B_up, - vec &v_up, - const smat &glo) const; + get_WLorentz_vsq_bsq_Seeds(vec &B_up, vec &v_up, + const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan(prim_vars &pv, cons_vars &cv) const; /* Called by 1DEntropy */ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, CCTK_REAL Bsq, - CCTK_REAL BiSi, EOSType &eos_th, prim_vars &pv, - cons_vars cv, const smat &gup, - const smat &glo) const; + CCTK_REAL BiSi, EOSType &eos_th, prim_vars &pv, cons_vars cv, + const smat &gup, + const smat &glo) const; template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, - CCTK_REAL x, EOSType &eos_th, cons_vars &cv) const; + funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, CCTK_REAL x, + EOSType &eos_th, cons_vars &cv) const; template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void @@ -55,9 +52,9 @@ public: /* Constructor */ template CCTK_HOST CCTK_DEVICE - CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( - EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len) { +CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( + EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len) { GammaIdealFluid = eos_th.gamma; maxIterations = maxIter; @@ -73,7 +70,7 @@ CCTK_HOST CCTK_DEVICE CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL c2p_1DEntropy::get_Ssq_Exact(vec &mom, - const smat &gup) const { + const smat &gup) const { CCTK_REAL Ssq; /* calculate S_squared */ @@ -83,15 +80,15 @@ c2p_1DEntropy::get_Ssq_Exact(vec &mom, Ssq += mom(Z) * (gup(X, Z) * mom(X) + gup(Y, Z) * mom(Y) + gup(Z, Z) * mom(Z)); - if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { - Ssq = fabs(Ssq); - } + // if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { + // Ssq = fabs(Ssq); + //} return Ssq; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL c2p_1DEntropy::get_Bsq_Exact(vec &B_up, - const smat &glo) const { + const smat &glo) const { vec B_low = calc_contraction(glo, B_up); return calc_contraction(B_low, B_up); // Bsq @@ -99,28 +96,28 @@ c2p_1DEntropy::get_Bsq_Exact(vec &B_up, CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL c2p_1DEntropy::get_BiSi_Exact(vec &Bvec, - vec &mom) const { + vec &mom) const { return Bvec(X) * mom(X) + Bvec(Y) * mom(Y) + Bvec(Z) * mom(Z); // BiSi } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec -c2p_1DEntropy::get_WLorentz_vsq_bsq_Seeds( - vec &B_up, vec &v_up, - const smat &glo) const { +c2p_1DEntropy::get_WLorentz_vsq_bsq_Seeds(vec &B_up, + vec &v_up, + const smat &glo) const { vec v_low = calc_contraction(glo, v_up); CCTK_REAL vsq = calc_contraction(v_low, v_up); CCTK_REAL VdotB = calc_contraction(v_low, B_up); CCTK_REAL VdotBsq = VdotB * VdotB; CCTK_REAL Bsq = get_Bsq_Exact(B_up, glo); - if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { - vsq = fabs(vsq); - } + // if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { + // vsq = fabs(vsq); + //} CCTK_REAL w_lor = 1. / sqrt(1. - vsq); CCTK_REAL bsq = ((Bsq) / (w_lor * w_lor)) + VdotBsq; - vec w_vsq_bsq{w_lor, vsq, bsq}; + vec w_vsq_bsq{ w_lor, vsq, bsq }; return w_vsq_bsq; //{w_lor, vsq, bsq} } @@ -130,40 +127,27 @@ c2p_1DEntropy::get_WLorentz_vsq_bsq_Seeds( template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, - CCTK_REAL Bsq, CCTK_REAL BiSi, - EOSType &eos_th, prim_vars &pv, - cons_vars cv, const smat &gup, - const smat &glo) const { - const CCTK_REAL qPalenzuela = cv.tau / cv.dens; - const CCTK_REAL rPalenzuela = Ssq / pow(cv.dens, 2); - const CCTK_REAL sPalenzuela = Bsq / cv.dens; - const CCTK_REAL tPalenzuela = BiSi / pow(cv.dens, 3. / 2.); - - // (i) - CCTK_REAL Wminus2 = - 1.0 - - (xPalenzuela_Sol * xPalenzuela_Sol * rPalenzuela + - (2.0 * xPalenzuela_Sol + sPalenzuela) * tPalenzuela * tPalenzuela) / - (xPalenzuela_Sol * xPalenzuela_Sol * (xPalenzuela_Sol + sPalenzuela) * - (xPalenzuela_Sol + sPalenzuela)); - Wminus2 = fmin(fmax(Wminus2, 1e-10), 1 - 1e-10); - const CCTK_REAL W_sol = pow(Wminus2, -0.5); - - // (ii) - pv.rho = cv.dens / W_sol; - - // (iii) - pv.eps = W_sol - 1.0 + (1.0 - W_sol * W_sol) * xPalenzuela_Sol / W_sol + - W_sol * (qPalenzuela - sPalenzuela + - tPalenzuela * tPalenzuela / - (2 * xPalenzuela_Sol * xPalenzuela_Sol) + - sPalenzuela / (2.0 * W_sol * W_sol)); - - // (iv) - // CCTK_REAL P_loc = get_Press_funcRhoEps(rho_loc, eps_loc); + CCTK_REAL Bsq, CCTK_REAL BiSi, EOSType &eos_th, + prim_vars &pv, cons_vars cv, + const smat &gup, + const smat &glo) const { + // Density, entropy, Ye + pv.rho = xEntropy_Sol; + pv.entropy = cv.dS / cv.dens; + pv.Ye = cv.dYe / cv.dens; + + // Lorentz factor + pv.w_lor = cv.dens / xEntropy_Sol; + + // Pressure and epsilon + pv.press = + eos_th.press_from_valid_rho_entropy_ye(xEntropySol, pv.entropy, pv.Ye); + pv.eps = eos_th.eps_from_valid_rho_entropy_ye(xEntropySol, pv.entropy, pv.Ye); // Taken from WZ2Prim (2DNRNoble) - CCTK_REAL Z_Sol = xPalenzuela_Sol * pv.rho * W_sol; + // Z_Sol = rho * h * w_lor * w_lor + CCTK_REAL Z_Sol = + (xEntropy_Sol + pv.eps * xEntropy_Sol + pv.press) * pv.w_lor * pv.w_lor; pv.vel(X) = (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / @@ -180,12 +164,6 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, (Z_Sol + Bsq); pv.vel(Z) += BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); - pv.w_lor = W_sol; - - pv.Ye = cv.dYe / cv.dens; - - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.Bvec = cv.dBvec; const vec Elow = calc_cross_product(pv.Bvec, pv.vel); @@ -195,18 +173,17 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, // See Appendix A.4 of https://arxiv.org/pdf/1112.0568 template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, - CCTK_REAL BiSi, CCTK_REAL x, - EOSType &eos_th, CCTK_REAL dens, - CCTK_REAL sstar, CCTK_REAL dYe) const { +c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, + CCTK_REAL x, EOSType &eos_th, + cons_vars &cv) const { - // We already divided dens, sstar and + // We already divided dens, dS and // dYe by sqrt(gamma) - const CCTK_REAL ent_loc = sstar/dens; - const CCTK_REAL ye_loc = dYe/dens; + const CCTK_REAL ent_loc = cv.dS / dens; + const CCTK_REAL ye_loc = cv.dYe / dens; - // Compute h_{cold} but using entropy + // Compute h using entropy const CCTK_REAL press_loc = eos_th.press_from_valid_rho_entropy_ye(x, ent_loc, ye_loc); @@ -215,25 +192,25 @@ c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, // Compute (A60) using // W = rho*h*lorentz*lorentz - const CCTK_REAL lor_loc = dens/x; - const CCTK_REAL h_loc = (1.0+eps_loc+press/x); - const CCTK_REAL W = x*h_loc*lor_loc*lor_loc; + const CCTK_REAL lor_loc = cv.dens / x; + const CCTK_REAL h_loc = (1.0 + eps_loc + press_loc / x); + const CCTK_REAL W = x * h_loc * lor_loc * lor_loc; // Compute (A61) - const CCTK_REAL Sfsq = (W*W*Ssq+BiSi*BiSi*(Bsq+2.0*W))/ - ((W+Bsq)*(W+Bsq)); + const CCTK_REAL Sfsq = + (W * W * Ssq + BiSi * BiSi * (Bsq + 2.0 * W)) / ((W + Bsq) * (W + Bsq)); // Compute (A62) - const CCTK_REAL rho = dens/sqrt(1.0+Sfsq/(dens*dens*h_loc*h_loc)); + const CCTK_REAL rho = + cv.dens / sqrt(1.0 + Sfsq / (cv.dens * cv.dens * h_loc * h_loc)); - return x-rho; + return x - rho; } template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void -c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, - cons_vars cv, CCTK_REAL sstar, - const smat &glo, c2p_report &rep) const { +c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, + const smat &glo, c2p_report &rep) const { ROOTSTAT status = ROOTSTAT::SUCCESS; rep.iters = 0; @@ -244,54 +221,72 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, /* Check validity of the 3-metric and compute its inverse */ const CCTK_REAL spatial_detg = calc_det(glo); const CCTK_REAL sqrt_detg = sqrt(spatial_detg); - if ((!isfinite(sqrt_detg)) || (sqrt_detg <= 0)) { + // if ((!isfinite(sqrt_detg)) || (sqrt_detg <= 0)) { + // rep.set_invalid_detg(sqrt_detg); + // set_to_nan(pv, cv); + // return; + //} + + // Check positive definiteness of spatial metric + // Sylvester's criterion, see + // https://en.wikipedia.org/wiki/Sylvester%27s_criterion + const bool minor1{ glo(X, X) > 0.0 }; + const bool minor2{ glo(X, X) * glo(Y, Y) - glo(X, Y) * glo(X, Y) > 0.0 }; + const bool minor3{ spatial_detg > 0.0 }; + + if (minor1 && minor2 && minor3) { + continue; + } else { rep.set_invalid_detg(sqrt_detg); set_to_nan(pv, cv); return; } + const smat gup = calc_inv(glo, spatial_detg); /* Undensitize the conserved vars */ cv.dens /= sqrt_detg; - cv.tau /= sqrt_detg; + // cv.tau /= sqrt_detg; cv.mom /= sqrt_detg; cv.dBvec /= sqrt_detg; cv.dYe /= sqrt_detg; - sstar /= sqrt_detg; + cv.dS /= sqrt_detg; if (cv.dens <= atmo.rho_cut) { rep.set_atmo_set(); atmo.set(pv, cv, glo); - eos_th.entropy_from_valid_rho_eps_ye(x,pv.eps,pv.Ye); return; } // compute primitive B seed from conserved B of current time step for better // guess - pv_seeds.Bvec = cv.dBvec; + // pv_seeds.Bvec = cv.dBvec; const CCTK_REAL Ssq = get_Ssq_Exact(cv.mom, gup); - const CCTK_REAL Bsq = get_Bsq_Exact(pv_seeds.Bvec, glo); - const CCTK_REAL BiSi = get_BiSi_Exact(pv_seeds.Bvec, cv.mom); - const vec w_vsq_bsq = get_WLorentz_vsq_bsq_Seeds( - pv_seeds.Bvec, pv_seeds.vel, glo); // this also recomputes pv_seeds.w_lor - pv_seeds.w_lor = w_vsq_bsq(0); + const CCTK_REAL Bsq = get_Bsq_Exact(cv.dBvec, glo); + const CCTK_REAL BiSi = get_BiSi_Exact(cv.dBvec, cv.mom); + // const vec w_vsq_bsq = get_WLorentz_vsq_bsq_Seeds( + // pv_seeds.Bvec, pv_seeds.vel, glo); // this also recomputes + // pv_seeds.w_lor + // pv_seeds.w_lor = w_vsq_bsq(0); // CCTK_REAL vsq_seed = w_vsq_bsq(1); // const CCTK_REAL bsq = w_vsq_bsq(2); - if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || - (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { - rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); - set_to_nan(pv, cv); - return; - } - - if (Bsq < 0) { - rep.set_neg_Bsq(Bsq); - set_to_nan(pv, cv); - return; - } - + // CHECK + // if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || + // (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { + // rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); + // set_to_nan(pv, cv); + // return; + //} + + // if (Bsq < 0) { + // rep.set_neg_Bsq(Bsq); + // set_to_nan(pv, cv); + // return; + //} + + // CHECK if (Bsq > Bsq_lim) { rep.set_B_limit(Bsq); set_to_nan(pv, cv); @@ -301,27 +296,39 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, /* update rho seed from cv and wlor */ // rho consistent with cv.rho should be better guess than rho from last // timestep - pv_seeds.rho = cv.dens / pv_seeds.w_lor; - - // Find x, this is the recovery process - const CCTK_INT minbits = std::numeric_limits::digits - 4; - const CCTK_INT maxiters = maxIterations; + // pv_seeds.rho = cv.dens / pv_seeds.w_lor; // See Appendix A.4 of https://arxiv.org/pdf/1112.0568 // Compute (A59) - CCTK_REAL a = cv.dens/sqrt(1.0+Ssq/(cv.dens*cv.dens)); + CCTK_REAL a = cv.dens / sqrt(1.0 + Ssq / (cv.dens * cv.dens)); CCTK_REAL b = cv.dens; auto fn = [&](auto x) { - return funcRoot_1DEntropy(Ssq, Bsq, BiSi, x, eos_th, - cv.dens, sstar, cv.dYe); + return funcRoot_1DEntropy(Ssq, Bsq, BiSi, x, eos_th, cv); }; + + // Important! + // Algo::brent terminates if the following accuracy is achieved + // abs(x - y) <= eps * min(abs(x), abs(y)), + // where x and y are the values of the bracket and + // eps = std::ldexp(1, -minbits) = 1 * 2^{-minbits} + // This should probably be changed in Algo::brent + + // We want to set the tolerance to its correct parameter + constexpr CCTK_REAL log2 = std::log(2.0); + const CCTK_INT minbits = int(abs(std::log(tolerance)) / log2); + const CCTK_REAL tolerance_0 = std::ldexp(double(1.0), -minbits); + // Old code: + // const CCTK_INT minbits = std::numeric_limits::digits - 4; + const CCTK_INT maxiters = maxIterations; + auto result = Algo::brent(fn, a, b, minbits, maxiters, rep.iters); - CCTK_REAL xEntropy_Sol = 0.5*(result.first+result.second); + CCTK_REAL xEntropy_Sol = 0.5 * (result.first + result.second); // Check solution and calculate primitives - // TODO:check if to pass result.first or xEntropy_Sol - if (rep.iters < maxiters && abs(fn(xEntropy_Sol)) < tolerance) { + // if (rep.iters < maxiters && abs(fn(xEntropy_Sol)) < tolerance) { + if (abs(result.first - result.second) <= + tolerance_0 * min(abs(result.first), abs(result.second))) { rep.status = c2p_report::SUCCESS; status = ROOTSTAT::SUCCESS; } else { @@ -332,39 +339,64 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, xEntropyToPrim(xEntropy_Sol, Ssq, Bsq, BiSi, eos_th, pv, cv, gup, glo); + // Lower velocity + const vec v_low = calc_contraction(glo, pv.vel); + // Computing b^t : this is b^0 * alp + const CCTK_REAL bst = pv.w_lor * calc_contraction(pv.Bvec, v_low); + // Computing b^mu b_mu + const CCTK_REAL bs2 = (Bsq + bst * bst) / (pv.w_lor * pv.w_lor); + // Recompute tau + cv.tau = (pv.w_lor * pv.w_lor * (pv.rho * (1.0 + pv.eps) + pv.press + bs2) - + (pv.press + 0.5 * bs2) - bst * bst) - + cv.dens; + // set to atmo if computed rho is below floor density if (pv.rho < atmo.rho_cut) { rep.set_atmo_set(); atmo.set(pv, cv, glo); - eos_th.entropy_from_valid_rho_temp_ye(x,,); + return; + } + + if (pv.rho > rho_strict) { + rep.adjust_cons = true; + // remove mass + pv.rho = rho_strict; + pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); + pv.entropy = + eos_th.entropy_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); return; } // check the validity of the computed eps auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); if (pv.eps > rgeps.max) { - //printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); + // printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); rep.adjust_cons = true; - if (pv.rho >= rho_strict) { - rep.set_range_eps(pv.eps); // sets adjust_cons to false by default - rep.adjust_cons = true; - set_to_nan(pv, cv); - return; - } + // if (pv.rho >= rho_strict) { + // rep.set_range_eps(pv.eps); // sets adjust_cons to false by default + // rep.adjust_cons = true; + // set_to_nan(pv, cv); + // return; + //} + pv.eps = rgeps.max; } else if (pv.eps < rgeps.min) { /* printf( - "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e \n", + "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e + \n", pv.eps, rgeps.min); printf(" Not adjusting cons.. \n"); */ - rep.set_range_eps(rgeps.min); // sets adjust_cons to true + // rep.set_range_eps(rgeps.min); // sets adjust_cons to true + rep.adjust_cons = true; + pv.eps = rgeps.min; } + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.entropy = eos_th.entropy_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); // TODO: check validity for Ye // check if computed velocities are within the specified limit - vec v_low = calc_contraction(glo, pv.vel); CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); CCTK_REAL sol_v = sqrt(vsq_Sol); if (sol_v > v_lim) { @@ -372,16 +404,21 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, printf("(sol_v > v_lim) is true! \n"); printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); */ + // add mass pv.rho = cv.dens / w_lim; - if (pv.rho >= rho_strict) { - rep.set_speed_limit({sol_v, sol_v, sol_v}); - set_to_nan(pv, cv); - return; - } + pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); + pv.entropy = + eos_th.entropy_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + // if (pv.rho >= rho_strict) { + // rep.set_speed_limit({ sol_v, sol_v, sol_v }); + // set_to_nan(pv, cv); + // return; + //} pv.vel *= v_lim / sol_v; pv.w_lor = w_lim; - pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), eos_th.rgeps.max); - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + // pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), + // eos_th.rgeps.max); + // pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); rep.adjust_cons = true; } @@ -400,7 +437,7 @@ c2p_1DPalenzuela::set_to_nan(prim_vars &pv, cons_vars &cv) const { /* Destructor */ CCTK_HOST CCTK_DEVICE - CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::~c2p_1DPalenzuela() { +CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::~c2p_1DPalenzuela() { // How to destruct properly a vector? } } // namespace Con2PrimFactory From a313b3fa2dd3205b068446238bb6170368542561 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 20 Sep 2024 06:29:23 -0500 Subject: [PATCH 09/50] EntropyInitial: Set entropy --- AsterX/configuration.ccl | 4 ++++ EntropyInitial/interface.ccl | 3 ++- EntropyInitial/schedule.ccl | 2 +- EntropyInitial/src/SetEntropy.cxx | 7 ++++++- 4 files changed, 13 insertions(+), 3 deletions(-) diff --git a/AsterX/configuration.ccl b/AsterX/configuration.ccl index 81cefe27..abcd2aac 100644 --- a/AsterX/configuration.ccl +++ b/AsterX/configuration.ccl @@ -1,3 +1,7 @@ # Configuration definitions for thorn AsterX REQUIRES Loop EOSX Con2PrimFactory ReconX + +PROVIDES AsterX +{ +} diff --git a/EntropyInitial/interface.ccl b/EntropyInitial/interface.ccl index c572b569..05c5f230 100644 --- a/EntropyInitial/interface.ccl +++ b/EntropyInitial/interface.ccl @@ -2,5 +2,6 @@ IMPLEMENTS: EntropyInitial INHERITS: ADMBaseX CarpetX HydroBaseX AsterX -USES INCLUDE HEADER: fixmath.hxx USES INCLUDE HEADER: loop_device.hxx +USES INCLUDE HEADER: eos.hxx +USES INCLUDE HEADER: eos_idealgas.hxx diff --git a/EntropyInitial/schedule.ccl b/EntropyInitial/schedule.ccl index 0baaf9ea..f4cdeabc 100644 --- a/EntropyInitial/schedule.ccl +++ b/EntropyInitial/schedule.ccl @@ -3,7 +3,7 @@ schedule SetEntropy IN HydroBaseX_PostInitial { LANG: C - READS: HydroBaseX::rho(everywhere) HydroBaseX::eps(everywhere) HydroBaseX::press(everywhere) + READS: HydroBaseX::rho(everywhere) HydroBaseX::eps(everywhere) WRITES: HydroBaseX::entropy(everywhere) } "Set initial entropy" diff --git a/EntropyInitial/src/SetEntropy.cxx b/EntropyInitial/src/SetEntropy.cxx index 15a705d8..ca22bfb9 100644 --- a/EntropyInitial/src/SetEntropy.cxx +++ b/EntropyInitial/src/SetEntropy.cxx @@ -9,9 +9,14 @@ #include #include +#include "eos.hxx" +#include "eos_idealgas.hxx" + extern "C" void SetEntropy(CCTK_ARGUMENTS) { + using namespace EOSX; + DECLARE_CCTK_ARGUMENTSX_SetEntropy; DECLARE_CCTK_PARAMETERS; @@ -21,7 +26,7 @@ extern "C" void SetEntropy(CCTK_ARGUMENTS) grid.nghostzones, [=] CCTK_DEVICE(const Loop::PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE { - entropy(p.I) = press(p.I)/rho(p.I); + entropy(p.I) = eos_th.entropy_from_valid_rho_eps_ye(rho(p.I),eps(p.I),1.0); }); } From aed869f883b558afa972edd5f9f0a83773ff83b0 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Tue, 22 Oct 2024 17:10:38 -0500 Subject: [PATCH 10/50] Con2PrimFactory: Small change --- Con2PrimFactory/interface.ccl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Con2PrimFactory/interface.ccl b/Con2PrimFactory/interface.ccl index 0470f717..105da7fd 100644 --- a/Con2PrimFactory/interface.ccl +++ b/Con2PrimFactory/interface.ccl @@ -5,7 +5,8 @@ INCLUDES HEADER: atmo.hxx IN atmo.hxx INCLUDES HEADER: prims.hxx IN prims.hxx INCLUDES HEADER: cons.hxx IN cons.hxx INCLUDES HEADER: c2p_2DNoble.hxx IN c2p_2DNoble.hxx -INCLUDES HEADER: c2p_1DPalenzuela.hxx IN c2p_1DPalenzuela.hxx +INCLUDES HEADER: c2p_1DPalenzuela.hxx IN c2p_1DPalenzuela.hxx +INCLUDES HEADER: c2p_1DEntropy.hxx IN c2p_1DEntropy.hxx USES INCLUDE HEADER: eos.hxx USES INCLUDE HEADER: eos_idealgas.hxx USES INCLUDE HEADER: roots.hxx From 738eb65e95d068b199e9b8b25e153b57b068f1be Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 24 Oct 2024 11:22:33 -0500 Subject: [PATCH 11/50] Con2PrimFactory: Rearrange limiting order --- Con2PrimFactory/src/c2p_1DEntropy.hxx | 73 +++++++++++++++------------ 1 file changed, 42 insertions(+), 31 deletions(-) diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index fb995da5..d054a12d 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -350,6 +350,11 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, (pv.press + 0.5 * bs2) - bst * bst) - cv.dens; + // ---------- + // Floor and ceiling for rho and velocity + // Keeps pressure the same and changes eps + // ---------- + // set to atmo if computed rho is below floor density if (pv.rho < atmo.rho_cut) { rep.set_atmo_set(); @@ -357,16 +362,47 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, return; } + // check if computed velocities are within the specified limit + CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); + CCTK_REAL sol_v = sqrt(vsq_Sol); + if (sol_v > v_lim) { + /* + printf("(sol_v > v_lim) is true! \n"); + printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); + */ + // add mass, keeps conserved density D + pv.rho = cv.dens / w_lim; + pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); + pv.entropy = + eos_th.entropy_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + // if (pv.rho >= rho_strict) { + // rep.set_speed_limit({ sol_v, sol_v, sol_v }); + // set_to_nan(pv, cv); + // return; + //} + pv.vel *= v_lim / sol_v; + pv.w_lor = w_lim; + // pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), + // eos_th.rgeps.max); + // pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + + rep.adjust_cons = true; + } + if (pv.rho > rho_strict) { rep.adjust_cons = true; - // remove mass + // remove mass, changes conserved density D pv.rho = rho_strict; pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); pv.entropy = eos_th.entropy_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); - return; } + // ---------- + // Floor and ceiling for eps + // Keeps rho the same and changes press + // ---------- + // check the validity of the computed eps auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); if (pv.eps > rgeps.max) { @@ -379,6 +415,8 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, // return; //} pv.eps = rgeps.max; + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.entropy = eos_th.entropy_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); } else if (pv.eps < rgeps.min) { /* printf( @@ -390,39 +428,12 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, // rep.set_range_eps(rgeps.min); // sets adjust_cons to true rep.adjust_cons = true; pv.eps = rgeps.min; + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.entropy = eos_th.entropy_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); } - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.entropy = eos_th.entropy_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); // TODO: check validity for Ye - // check if computed velocities are within the specified limit - CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); - CCTK_REAL sol_v = sqrt(vsq_Sol); - if (sol_v > v_lim) { - /* - printf("(sol_v > v_lim) is true! \n"); - printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); - */ - // add mass - pv.rho = cv.dens / w_lim; - pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); - pv.entropy = - eos_th.entropy_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); - // if (pv.rho >= rho_strict) { - // rep.set_speed_limit({ sol_v, sol_v, sol_v }); - // set_to_nan(pv, cv); - // return; - //} - pv.vel *= v_lim / sol_v; - pv.w_lor = w_lim; - // pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), - // eos_th.rgeps.max); - // pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - - rep.adjust_cons = true; - } - // Recompute cons if prims have been adjusted if (rep.adjust_cons) { cv.from_prim(pv, glo); From 9f2634c229a39debe000873c70c6f582a1d37539 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 24 Oct 2024 12:34:14 -0500 Subject: [PATCH 12/50] Con2PrimFactory: Add check on conservatives after failure --- Con2PrimFactory/param.ccl | 6 +++++ Con2PrimFactory/src/c2p.hxx | 1 + Con2PrimFactory/src/c2p_1DEntropy.hxx | 31 +++++++++++++++++++++--- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 7 ++++-- Con2PrimFactory/src/c2p_2DNoble.hxx | 7 ++++-- Con2PrimFactory/src/test.cxx | 4 +-- 6 files changed, 47 insertions(+), 9 deletions(-) diff --git a/Con2PrimFactory/param.ccl b/Con2PrimFactory/param.ccl index 36b2ec39..77916326 100644 --- a/Con2PrimFactory/param.ccl +++ b/Con2PrimFactory/param.ccl @@ -113,3 +113,9 @@ CCTK_REAL vwlim_BH " Maximum zvec (v*w) allowed in regions where alp &mom, diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index d054a12d..b260ce69 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -14,7 +14,8 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy( EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len); + CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL consError); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(vec &mom, const smat &gup) const; @@ -54,7 +55,8 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len) { + CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL consError) { GammaIdealFluid = eos_th.gamma; maxIterations = maxIter; @@ -66,6 +68,7 @@ CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( v_lim = vw_lim / w_lim; Bsq_lim = B_lim * B_lim; atmo = atm; + cons_error = consError; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL @@ -325,8 +328,11 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, CCTK_REAL xEntropy_Sol = 0.5 * (result.first + result.second); + xEntropyToPrim(xEntropy_Sol, Ssq, Bsq, BiSi, eos_th, pv, cv, gup, glo); + // Check solution and calculate primitives // if (rep.iters < maxiters && abs(fn(xEntropy_Sol)) < tolerance) { + /* if (abs(result.first - result.second) <= tolerance_0 * min(abs(result.first), abs(result.second))) { rep.status = c2p_report::SUCCESS; @@ -336,8 +342,27 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, rep.set_root_conv(); status = ROOTSTAT::NOT_CONVERGED; } + */ + if (abs(result.first - result.second) > + tolerance_0 * min(abs(result.first), abs(result.second))) { - xEntropyToPrim(xEntropy_Sol, Ssq, Bsq, BiSi, eos_th, pv, cv, gup, glo); + // check primitives against conservatives + cons_vars cv_check; + cv_check.from_prim(pv, glo); + CCTK_REAL max_error = sqrt(max({pow(cv_check.dens-cv.dens,2.0)/pow(cv.dens,2.0), + pow(cv_check.mom(0)-cv.mom(0),2.0)/pow(cv.mom(0),2.0), + pow(cv_check.mom(1)-cv.mom(1),2.0)/pow(cv.mom(1),2.0), + pow(cv_check.mom(2)-cv.mom(2),2.0)/pow(cv.mom(2),2.0), + pow(cv_check.tau-cv.tau,2.0)/pow(cv.tau,2.0)})); + + // reject only if mismatch in conservatives is inappropriate, else accept + if (max_err >= cons_error) { + // set status to root not converged + rep.set_root_conv(); + status = ROOTSTAT::NOT_CONVERGED; + return; + } + } // Lower velocity const vec v_low = calc_contraction(glo, pv.vel); diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index d06a866c..32b6d7a1 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -15,7 +15,8 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela( EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len); + CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL consError); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(vec &mom, @@ -58,7 +59,8 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::c2p_1DPalenzuela( EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len) { + CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL consError) { GammaIdealFluid = eos_th.gamma; maxIterations = maxIter; @@ -70,6 +72,7 @@ CCTK_HOST CCTK_DEVICE v_lim = vw_lim / w_lim; Bsq_lim = B_lim * B_lim; atmo = atm; + cons_error = consError; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 87d0c538..519f19df 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -16,7 +16,8 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble( EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len); + CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL consError); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(vec &mom, const smat &gup) const; @@ -61,7 +62,8 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble::c2p_2DNoble( EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len) { + CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL consError) { GammaIdealFluid = eos_th.gamma; maxIterations = maxIter; @@ -73,6 +75,7 @@ CCTK_HOST v_lim = vw_lim / w_lim; Bsq_lim = B_lim * B_lim; atmo = atm; + cons_error = consError; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index c80b592c..2c1f9b07 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -33,8 +33,8 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { 1.0, 0.0, 1.0}; // xx, xy, xz, yy, yz, zz // Con2Prim objects - c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true); - c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true); + c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.); + c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.); // Construct error report object: c2p_report rep_Noble; From fef8269ac2b8ce465fd6dbf338327c764b248889 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 1 Nov 2024 15:57:53 -0500 Subject: [PATCH 13/50] EOSX: Remove swp file --- EOSX/.README.swp | Bin 12288 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 EOSX/.README.swp diff --git a/EOSX/.README.swp b/EOSX/.README.swp deleted file mode 100644 index fcc2e49af28bdb6a545847f43c21dcc027265a65..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12288 zcmeI&y>1jS5C`xHl!y<3pmst56#H=rQSKsyh{6g*+=&wjaIJUOdvWg8KD>4y72*x( zcoI6`9jK`(kaz()X2T@~(n%Chfc_(mY->FG@#|LWJbk(|5Z$;#9G8f`fB9UTefx$! z@%%s@P2^M?X>?m%7$FbFhlS7SemhTC>t+>xzPwdA}%T? zYxTmqNlZg$4|S=WsH_u*(rFtSp`HinwKa{fmEcCNVxmqghQaZPb43*Wv7o*#lqr-r zj!n^jFznMnYU4STyV=~@6q(Z#v0LmL Date: Mon, 4 Nov 2024 13:05:42 -0600 Subject: [PATCH 14/50] Compiling version --- AsterX/interface.ccl | 2 +- AsterX/param.ccl | 1 + AsterX/src/con2prim.cxx | 14 ++++---- Con2PrimFactory/src/atmo.hxx | 12 +++---- Con2PrimFactory/src/c2p.hxx | 2 +- Con2PrimFactory/src/c2p_1DEntropy.hxx | 22 ++++++------ Con2PrimFactory/src/c2p_report.hxx | 6 ++-- Con2PrimFactory/src/cons.hxx | 2 +- Con2PrimFactory/src/prims.hxx | 12 +++---- Con2PrimFactory/src/test.cxx | 4 +-- EOSX/src/eos_idealgas.hxx | 48 +++++++++++++++++++++++++++ EntropyInitial/interface.ccl | 2 +- EntropyInitial/param.ccl | 13 +++++++- EntropyInitial/src/SetEntropy.cxx | 7 +++- FishboneMoncriefIDX/interface.ccl | 2 +- 15 files changed, 108 insertions(+), 41 deletions(-) diff --git a/AsterX/interface.ccl b/AsterX/interface.ccl index 963feae2..ff13f609 100644 --- a/AsterX/interface.ccl +++ b/AsterX/interface.ccl @@ -8,7 +8,7 @@ USES INCLUDE HEADER: fixmath.hxx USES INCLUDE HEADER: loop_device.hxx USES INCLUDE HEADER: eos_1p.hxx eos_polytropic.hxx USES INCLUDE HEADER: eos.hxx eos_idealgas.hxx -USES INCLUDE HEADER: c2p.hxx c2p_2DNoble.hxx c2p_1DPalenzuela.hxx +USES INCLUDE HEADER: c2p.hxx c2p_2DNoble.hxx c2p_1DPalenzuela.hxx c2p_1DEntropy.hxx USES INCLUDE HEADER: reconstruct.hxx USES INCLUDE HEADER: aster_fd.hxx aster_interp.hxx aster_utils.hxx diff --git a/AsterX/param.ccl b/AsterX/param.ccl index b3cad544..c04b21e6 100644 --- a/AsterX/param.ccl +++ b/AsterX/param.ccl @@ -120,6 +120,7 @@ USES CCTK_REAL alp_thresh USES CCTK_REAL rho_BH USES CCTK_REAL eps_BH USES CCTK_REAL vwlim_BH +USES CCTK_REAL cons_error_limit SHARES: ReconX USES KEYWORD reconstruction_method diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 761089fc..d0e909fd 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -83,15 +83,16 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, eps_atm = std::min(std::max(eos_th.rgeps.min, eps_atm), eos_th.rgeps.max); press_atm = eos_th.press_from_valid_rho_eps_ye(rho_atm, eps_atm, Ye_atmo); } - atmosphere atmo(rho_atm, eps_atm, Ye_atmo, press_atm, rho_atmo_cut); + CCTK_REAL kappa_atm = press_atm/pow(rho_atm,gl_gamma); + atmosphere atmo(rho_atm, eps_atm, Ye_atmo, press_atm, kappa_atm, rho_atmo_cut); // Construct Noble c2p object: c2p_2DNoble c2p_Noble(eos_th, atmo, max_iter, c2p_tol, rho_strict, vw_lim, - B_lim, Ye_lenient); + B_lim, Ye_lenient, cons_error_limit); // Construct Palenzuela c2p object: c2p_1DPalenzuela c2p_Pal(eos_th, atmo, max_iter, c2p_tol, rho_strict, - vw_lim, B_lim, Ye_lenient); + vw_lim, B_lim, Ye_lenient, cons_error_limit); /* Get covariant metric */ const smat glo( @@ -111,13 +112,14 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, CCTK_REAL dummy_Ye = 0.5; CCTK_REAL dummy_dYe = 0.5; prim_vars pv; - prim_vars pv_seeds{saved_rho(p.I), saved_eps(p.I), dummy_Ye, press(p.I), + prim_vars pv_seeds{saved_rho(p.I), saved_eps(p.I), dummy_Ye, press(p.I), entropy(p.I), v_up, wlor, Bup}; // Note that cv are densitized, i.e. they all include sqrt_detg cons_vars cv{dens(p.I), {momx(p.I), momy(p.I), momz(p.I)}, tau(p.I), dummy_dYe, + sstar(p.I), {dBx(p.I), dBy(p.I), dBz(p.I)}}; if (dens(p.I) <= sqrt_detg * rho_atmo_cut) { @@ -271,7 +273,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, CCTK_REAL Ex, Ey, Ez; // Write back pv - pv.scatter(rho(p.I), eps(p.I), dummy_Ye, press(p.I), velx(p.I), vely(p.I), + pv.scatter(rho(p.I), eps(p.I), dummy_Ye, press(p.I), entropy(p.I),velx(p.I), vely(p.I), velz(p.I), wlor, Bvecx(p.I), Bvecy(p.I), Bvecz(p.I), Ex, Ey, Ez); zvec_x(p.I) = wlor * pv.vel(0); @@ -287,7 +289,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, // Write back cv cv.scatter(dens(p.I), momx(p.I), momy(p.I), momz(p.I), tau(p.I), dummy_Ye, - dBx(p.I), dBy(p.I), dBz(p.I)); + sstar(p.I), dBx(p.I), dBy(p.I), dBz(p.I)); // Update saved prims saved_rho(p.I) = rho(p.I); diff --git a/Con2PrimFactory/src/atmo.hxx b/Con2PrimFactory/src/atmo.hxx index 551cce54..98de509d 100644 --- a/Con2PrimFactory/src/atmo.hxx +++ b/Con2PrimFactory/src/atmo.hxx @@ -18,16 +18,16 @@ struct atmosphere { CCTK_REAL eps_atmo; CCTK_REAL ye_atmo; CCTK_REAL press_atmo; - CCTK_REAL entropy_atmo; + CCTK_REAL kappa_atmo; CCTK_REAL rho_cut; CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline atmosphere() = default; CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline atmosphere( - CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL Ye_, CCTK_REAL press_, CCTK_REAL entropy_, + CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL Ye_, CCTK_REAL press_, CCTK_REAL kappa_, CCTK_REAL rho_cut_) - : rho_atmo(rho_), eps_atmo(eps_), ye_atmo(Ye_), press_atmo(press_), entropy_atmo(entropy_), + : rho_atmo(rho_), eps_atmo(eps_), ye_atmo(Ye_), press_atmo(press_), kappa_atmo(kappa_), rho_cut(rho_cut_) {} CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline atmosphere & @@ -39,7 +39,7 @@ struct atmosphere { eps_atmo = other.eps_atmo; ye_atmo = other.ye_atmo; press_atmo = other.press_atmo; - entropy_atmo = other.entropy_atmo; + kappa_atmo = other.kappa_atmo; rho_cut = other.rho_cut; return *this; } @@ -51,7 +51,7 @@ struct atmosphere { pv.eps = eps_atmo; pv.Ye = ye_atmo; pv.press = press_atmo; - pv.entropy = entropy_atmo; + pv.kappa = kappa_atmo; pv.vel(0) = 0.0; pv.vel(1) = 0.0; pv.vel(2) = 0.0; @@ -71,7 +71,7 @@ struct atmosphere { cv.mom(1) = 0.0; cv.mom(2) = 0.0; cv.dYe = cv.dens * ye_atmo; - cv.dS = cv.dens * entropy_atmo; + cv.dS = cv.dens * kappa_atmo; const vec &B_up = pv.Bvec; const vec B_low = calc_contraction(g, B_up); CCTK_REAL Bsq = calc_contraction(B_up, B_low); diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index 63c0198e..10cac36a 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -46,7 +46,7 @@ protected: CCTK_REAL vw_lim; CCTK_REAL Bsq_lim; atmosphere atmo; - CCTK_REAL cons_err; + CCTK_REAL cons_error; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(vec &mom, diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index b260ce69..2078e2ac 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -136,7 +136,7 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, const smat &glo) const { // Density, entropy, Ye pv.rho = xEntropy_Sol; - pv.entropy = cv.dS / cv.dens; + pv.kappa = cv.dS / cv.dens; pv.Ye = cv.dYe / cv.dens; // Lorentz factor @@ -144,8 +144,8 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, // Pressure and epsilon pv.press = - eos_th.press_from_valid_rho_entropy_ye(xEntropySol, pv.entropy, pv.Ye); - pv.eps = eos_th.eps_from_valid_rho_entropy_ye(xEntropySol, pv.entropy, pv.Ye); + eos_th.press_from_valid_rho_kappa_ye(xEntropySol, pv.kappa, pv.Ye); + pv.eps = eos_th.eps_from_valid_rho_kappa_ye(xEntropySol, pv.kappa, pv.Ye); // Taken from WZ2Prim (2DNRNoble) // Z_Sol = rho * h * w_lor * w_lor @@ -188,10 +188,10 @@ c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, // Compute h using entropy const CCTK_REAL press_loc = - eos_th.press_from_valid_rho_entropy_ye(x, ent_loc, ye_loc); + eos_th.press_from_valid_rho_kappa_ye(x, ent_loc, ye_loc); const CCTK_REAL eps_loc = - eos_th.eps_from_valid_rho_entropy_ye(x, ent_loc, ye_loc); + eos_th.eps_from_valid_rho_kappa_ye(x, ent_loc, ye_loc); // Compute (A60) using // W = rho*h*lorentz*lorentz @@ -398,8 +398,8 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, // add mass, keeps conserved density D pv.rho = cv.dens / w_lim; pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); - pv.entropy = - eos_th.entropy_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); // if (pv.rho >= rho_strict) { // rep.set_speed_limit({ sol_v, sol_v, sol_v }); // set_to_nan(pv, cv); @@ -419,8 +419,8 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, // remove mass, changes conserved density D pv.rho = rho_strict; pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); - pv.entropy = - eos_th.entropy_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); } // ---------- @@ -441,7 +441,7 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, //} pv.eps = rgeps.max; pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.entropy = eos_th.entropy_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); } else if (pv.eps < rgeps.min) { /* printf( @@ -454,7 +454,7 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, rep.adjust_cons = true; pv.eps = rgeps.min; pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.entropy = eos_th.entropy_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); } // TODO: check validity for Ye diff --git a/Con2PrimFactory/src/c2p_report.hxx b/Con2PrimFactory/src/c2p_report.hxx index ec954e25..f4108f14 100644 --- a/Con2PrimFactory/src/c2p_report.hxx +++ b/Con2PrimFactory/src/c2p_report.hxx @@ -22,7 +22,7 @@ public: NANS_IN_CONS, ///< One or more evolved variables is NAN/INF RANGE_RHO, ///< Mass density outside EOS range RANGE_EPS, ///< Fluid internal energy outside EOS range - RANGE_ENT, ///< Evolved entropy outside EOS range + RANGE_KAPPA, ///< Evolved entropy outside EOS range SPEED_LIMIT, ///< Speed limit exceeded RANGE_YE, ///< Electron fraction outside EOS range B_LIMIT, ///< Magnetization above limit @@ -159,7 +159,7 @@ public: CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_range_entropy(CCTK_REAL entropy_) { - status = RANGE_ENT; + status = RANGE_KAPPA; set_atmo = false; adjust_cons = true; // we adjust cons in this case! entropy = entropy_; @@ -247,7 +247,7 @@ public: case RANGE_EPS: printf("Specific energy was out of range! eps readjusted to = %16.8e \n", eps); break; - case RANGE_ENT: + case RANGE_KAPPA: printf("Evolved entropy was out of range! entropy readjusted to = %16.8e \n", entropy); break; case SPEED_LIMIT: diff --git a/Con2PrimFactory/src/cons.hxx b/Con2PrimFactory/src/cons.hxx index 9f283948..d1fc9321 100644 --- a/Con2PrimFactory/src/cons.hxx +++ b/Con2PrimFactory/src/cons.hxx @@ -69,7 +69,7 @@ struct cons_vars { dBvec = sqrt_detg * pv.Bvec; dYe = dens * pv.Ye; - dS = dens * pv.entropy; + dS = dens * pv.kappa; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void diff --git a/Con2PrimFactory/src/prims.hxx b/Con2PrimFactory/src/prims.hxx index 00e89fa0..d1eaa83b 100644 --- a/Con2PrimFactory/src/prims.hxx +++ b/Con2PrimFactory/src/prims.hxx @@ -16,7 +16,7 @@ struct prim_vars { CCTK_REAL eps; CCTK_REAL Ye; CCTK_REAL press; - CCTK_REAL entropy; + CCTK_REAL kappa; vec vel; CCTK_REAL w_lor; vec Bvec; @@ -27,13 +27,13 @@ struct prim_vars { /// Construct from single variables. CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline prim_vars( - CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL ye_, CCTK_REAL press_, CCTK_REAL entropy_, + CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL ye_, CCTK_REAL press_, CCTK_REAL kappa_, vec vel_, CCTK_REAL w_lor_, vec Bvec_) - : rho(rho_), eps(eps_), Ye(ye_), press(press_), entropy(entropy_), vel(vel_), w_lor(w_lor_), + : rho(rho_), eps(eps_), Ye(ye_), press(press_), kappa(kappa_), vel(vel_), w_lor(w_lor_), Bvec(Bvec_){}; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void - scatter(CCTK_REAL &rho_, CCTK_REAL &eps_, CCTK_REAL &ye_, CCTK_REAL &press_, CCTK_REAL &entropy_, + scatter(CCTK_REAL &rho_, CCTK_REAL &eps_, CCTK_REAL &ye_, CCTK_REAL &press_, CCTK_REAL &kappa_, CCTK_REAL &velx_, CCTK_REAL &vely_, CCTK_REAL &velz_, CCTK_REAL &w_lor_, CCTK_REAL &Bvec_x_, CCTK_REAL &Bvec_y_, CCTK_REAL &Bvec_z_, CCTK_REAL &E_x_, CCTK_REAL &E_y_, @@ -42,7 +42,7 @@ struct prim_vars { eps_ = eps; ye_ = Ye; press_ = press; - entropy_ = entropy; + kappa_ = kappa; velx_ = vel(0); vely_ = vel(1); velz_ = vel(2); @@ -56,7 +56,7 @@ struct prim_vars { } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan() { - rho = eps = Ye = press = entropy = vel(0) = vel(1) = vel(2) = w_lor = Bvec(0) = + rho = eps = Ye = press = kappa = vel(0) = vel(1) = vel(2) = w_lor = Bvec(0) = Bvec(1) = Bvec(2) = E(0) = E(1) = E(2) = std::numeric_limits::quiet_NaN(); } diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index 2c1f9b07..162bb184 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -26,7 +26,7 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { const eos_idealgas eos_th(2.0, 938.985, rgeps, rgrho, rgye); // Setting up atmosphere - atmosphere atmo(1e-10, 1e-8, 0.5, 1e-8, 0.001); + atmosphere atmo(1e-10, 1e-8, 0.5, 1e-8, 1e-10, 0.001); // Metric const smat g{1.0, 0.0, 0.0, @@ -42,7 +42,7 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { prim_vars pv; // rho(p.I), eps(p.I), dummy_Ye, press(p.I),v_up, wlor, Bup - prim_vars pv_seeds{0.125, 0.8, 0.5, 0.1, {0, 0, 0}, 1, {0.5, -1.0, 0}}; + prim_vars pv_seeds{0.125, 0.8, 0.5, 0.1, 100,{0, 0, 0}, 1, {0.5, -1.0, 0}}; // cons_vars cv{dens(p.I), {momx(p.I), momy(p.I), momz(p.I)}, tau(p.I), // dummy_dYe, {dBx(p.I), dBy(p.I), dBz(p.I)}}; diff --git a/EOSX/src/eos_idealgas.hxx b/EOSX/src/eos_idealgas.hxx index e355bcd6..e913c66b 100644 --- a/EOSX/src/eos_idealgas.hxx +++ b/EOSX/src/eos_idealgas.hxx @@ -84,6 +84,27 @@ public: const CCTK_REAL ye ///< Electron fraction \f$ Y_e \f$ ) const; + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL + press_from_valid_rho_kappa_ye( + const CCTK_REAL rho, + const CCTK_REAL kappa, // p/rho^gamma + const CCTK_REAL ye + ) const; + + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL + eps_from_valid_rho_kappa_ye( + const CCTK_REAL rho, + const CCTK_REAL kappa, // p/rho^gamma + const CCTK_REAL ye + ) const; + + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL + kappa_from_valid_rho_eps_ye( + const CCTK_REAL rho, + const CCTK_REAL eps, + const CCTK_REAL ye + ) const; + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline range range_eps_from_valid_rho_ye( const CCTK_REAL rho, ///< Rest mass density \f$ \rho \f$ @@ -173,6 +194,33 @@ eos_idealgas::eps_from_valid_rho_temp_ye(const CCTK_REAL rho, return temp / temp_over_eps; } +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL +eos_idealgas::press_from_valid_rho_kappa_ye( + const CCTK_REAL rho, + const CCTK_REAL kappa, // p/rho^gamma + const CCTK_REAL ye +) const { + return kappa*pow(rho,gamma); +} + +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL +eos_idealgas::eps_from_valid_rho_kappa_ye( + const CCTK_REAL rho, + const CCTK_REAL kappa, // p/rho^gamma + const CCTK_REAL ye +) const { + return kappa*pow(rho,gamma-1.0)/(gamma-1.0); +}; + +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL +eos_idealgas::kappa_from_valid_rho_eps_ye( + const CCTK_REAL rho, + const CCTK_REAL eps, + const CCTK_REAL ye +) const { + return (gamma-1.0)*eps*pow(rho,1.0-gamma); +}; + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline eos::range eos_idealgas::range_eps_from_valid_rho_ye(const CCTK_REAL rho, const CCTK_REAL ye) const { diff --git a/EntropyInitial/interface.ccl b/EntropyInitial/interface.ccl index 05c5f230..2dc06d3d 100644 --- a/EntropyInitial/interface.ccl +++ b/EntropyInitial/interface.ccl @@ -1,6 +1,6 @@ IMPLEMENTS: EntropyInitial -INHERITS: ADMBaseX CarpetX HydroBaseX AsterX +INHERITS: ADMBaseX HydroBaseX AsterX USES INCLUDE HEADER: loop_device.hxx USES INCLUDE HEADER: eos.hxx diff --git a/EntropyInitial/param.ccl b/EntropyInitial/param.ccl index 8b137891..bd81bbf3 100644 --- a/EntropyInitial/param.ccl +++ b/EntropyInitial/param.ccl @@ -1 +1,12 @@ - +SHARES: EOSX +USES KEYWORD evolution_eos +USES CCTK_REAL poly_gamma +USES CCTK_REAL poly_k +USES CCTK_REAL gl_gamma +USES CCTK_REAL eps_min +USES CCTK_REAL eps_max +USES CCTK_REAL rho_min +USES CCTK_REAL rho_max +USES CCTK_REAL ye_min +USES CCTK_REAL ye_max +USES CCTK_REAL particle_mass diff --git a/EntropyInitial/src/SetEntropy.cxx b/EntropyInitial/src/SetEntropy.cxx index ca22bfb9..0d41d670 100644 --- a/EntropyInitial/src/SetEntropy.cxx +++ b/EntropyInitial/src/SetEntropy.cxx @@ -20,13 +20,18 @@ extern "C" void SetEntropy(CCTK_ARGUMENTS) DECLARE_CCTK_ARGUMENTSX_SetEntropy; DECLARE_CCTK_PARAMETERS; + eos::range rgeps(eps_min, eps_max), rgrho(rho_min, rho_max), + rgye(ye_min, ye_max); + + const eos_idealgas eos_th(gl_gamma, particle_mass, rgeps, rgrho, rgye); + CCTK_VINFO("Set the entropy!"); grid.loop_all_device<1, 1, 1>( grid.nghostzones, [=] CCTK_DEVICE(const Loop::PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE { - entropy(p.I) = eos_th.entropy_from_valid_rho_eps_ye(rho(p.I),eps(p.I),1.0); + entropy(p.I) = eos_th.kappa_from_valid_rho_eps_ye(rho(p.I),eps(p.I),1.0); }); } diff --git a/FishboneMoncriefIDX/interface.ccl b/FishboneMoncriefIDX/interface.ccl index b2fb062a..d0edbe76 100644 --- a/FishboneMoncriefIDX/interface.ccl +++ b/FishboneMoncriefIDX/interface.ccl @@ -1,6 +1,6 @@ IMPLEMENTS: FishboneMoncriefIDX -INHERITS: ADMBaseX CarpetX HydroBaseX AsterX +INHERITS: ADMBaseX HydroBaseX AsterX #USES INCLUDE HEADER: fixmath.hxx USES INCLUDE HEADER: loop_device.hxx From dcdf11bc66a96c4deec3edd8f10f231c6a21ee25 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Tue, 5 Nov 2024 14:43:55 -0600 Subject: [PATCH 15/50] Add entropy c2p to AsterX --- AsterX/param.ccl | 4 ++++ AsterX/src/con2prim.cxx | 17 ++++++++++++++--- Con2PrimFactory/src/c2p_1DEntropy.hxx | 22 ++++++++++------------ Con2PrimFactory/src/c2p_report.hxx | 15 --------------- 4 files changed, 28 insertions(+), 30 deletions(-) diff --git a/AsterX/param.ccl b/AsterX/param.ccl index c04b21e6..95929f27 100644 --- a/AsterX/param.ccl +++ b/AsterX/param.ccl @@ -15,6 +15,10 @@ BOOLEAN use_uct "Shall we use the Upwind-CT method to compute the electric field { } "no" +BOOLEAN use_entropy_fix "Shall we use inversion based on entropy as a backup?" STEERABLE=always +{ +} "no" + KEYWORD flux_type "Flux solver" STEERABLE=always { "LxF" :: "" diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index d0e909fd..df7ed983 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -8,6 +8,7 @@ #include "c2p.hxx" #include "c2p_1DPalenzuela.hxx" #include "c2p_2DNoble.hxx" +#include "c2p_1DEntropy.hxx" #include "eos_1p.hxx" #include "eos_polytropic.hxx" @@ -94,6 +95,10 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, c2p_1DPalenzuela c2p_Pal(eos_th, atmo, max_iter, c2p_tol, rho_strict, vw_lim, B_lim, Ye_lenient, cons_error_limit); + // Construct Entropy c2p object: + c2p_1DEntropy c2p_Ent(eos_th, atmo, max_iter, c2p_tol, rho_strict, + vw_lim, B_lim, Ye_lenient, cons_error_limit); + /* Get covariant metric */ const smat glo( [&](int i, int j) ARITH_INLINE { return calc_avg_v2c(gf_g(i, j), p); }); @@ -160,6 +165,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, // Construct error report object: c2p_report rep_first; c2p_report rep_second; + c2p_report rep_ent; // Invert entropy here entropy(p.I) = sstar(p.I)/dens(p.I); @@ -201,12 +207,16 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, printf("Second C2P failed too :( :( \n"); rep_second.debug_message(); + if (use_entropy_fix) { + c2p_Ent.solve(eos_th, pv, cv, glo, rep_ent); + } + // Treatment for BH interiors after C2P failures // NOTE: By default, alp_thresh=0 so the if condition below is never // triggered. One must be very careful when using this functionality and // must correctly set alp_thresh, rho_BH, eps_BH and vwlim_BH in the // parfile - if (alp(p.I) < alp_thresh) { + if ((alp(p.I) < alp_thresh) && rep_ent.failed()) { if ((pv_seeds.rho > rho_BH) || (pv_seeds.eps > eps_BH)) { pv.rho = rho_BH; // typically set to 0.01% to 1% of rho_max of initial // NS or disk @@ -225,12 +235,13 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, cv.from_prim(pv, glo); rep_first.set_atmo = 0; rep_second.set_atmo = 0; + rep_ent.set_atmo = 0; } } - con2prim_flag(p.I) = 0; + con2prim_flag(p.I) = rep_ent.failed() ? 0 : 1; } - if (rep_first.set_atmo && rep_second.set_atmo) { + if (rep_first.set_atmo && rep_second.set_atmo && rep_ent.set_atmo) { if (debug_mode) { printf( "WARNING: \n" diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 2078e2ac..56d22dbe 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -43,7 +43,7 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void - solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cons_vars cv, + solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, const smat &glo, c2p_report &rep) const; /* Destructor */ @@ -144,8 +144,8 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, // Pressure and epsilon pv.press = - eos_th.press_from_valid_rho_kappa_ye(xEntropySol, pv.kappa, pv.Ye); - pv.eps = eos_th.eps_from_valid_rho_kappa_ye(xEntropySol, pv.kappa, pv.Ye); + eos_th.press_from_valid_rho_kappa_ye(xEntropy_Sol, pv.kappa, pv.Ye); + pv.eps = eos_th.eps_from_valid_rho_kappa_ye(xEntropy_Sol, pv.kappa, pv.Ye); // Taken from WZ2Prim (2DNRNoble) // Z_Sol = rho * h * w_lor * w_lor @@ -183,8 +183,8 @@ c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, // We already divided dens, dS and // dYe by sqrt(gamma) - const CCTK_REAL ent_loc = cv.dS / dens; - const CCTK_REAL ye_loc = cv.dYe / dens; + const CCTK_REAL ent_loc = cv.dS / cv.dens; + const CCTK_REAL ye_loc = cv.dYe / cv.dens; // Compute h using entropy const CCTK_REAL press_loc = @@ -237,9 +237,7 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, const bool minor2{ glo(X, X) * glo(Y, Y) - glo(X, Y) * glo(X, Y) > 0.0 }; const bool minor3{ spatial_detg > 0.0 }; - if (minor1 && minor2 && minor3) { - continue; - } else { + if (!(minor1 && minor2 && minor3)) { rep.set_invalid_detg(sqrt_detg); set_to_nan(pv, cv); return; @@ -317,7 +315,7 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, // This should probably be changed in Algo::brent // We want to set the tolerance to its correct parameter - constexpr CCTK_REAL log2 = std::log(2.0); + const CCTK_REAL log2 = std::log(2.0); const CCTK_INT minbits = int(abs(std::log(tolerance)) / log2); const CCTK_REAL tolerance_0 = std::ldexp(double(1.0), -minbits); // Old code: @@ -356,7 +354,7 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, pow(cv_check.tau-cv.tau,2.0)/pow(cv.tau,2.0)})); // reject only if mismatch in conservatives is inappropriate, else accept - if (max_err >= cons_error) { + if (max_error >= cons_error) { // set status to root not converged rep.set_root_conv(); status = ROOTSTAT::NOT_CONVERGED; @@ -466,14 +464,14 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void -c2p_1DPalenzuela::set_to_nan(prim_vars &pv, cons_vars &cv) const { +c2p_1DEntropy::set_to_nan(prim_vars &pv, cons_vars &cv) const { pv.set_to_nan(); cv.set_to_nan(); } /* Destructor */ CCTK_HOST CCTK_DEVICE -CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::~c2p_1DPalenzuela() { +CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::~c2p_1DEntropy() { // How to destruct properly a vector? } } // namespace Con2PrimFactory diff --git a/Con2PrimFactory/src/c2p_report.hxx b/Con2PrimFactory/src/c2p_report.hxx index f4108f14..b7225b24 100644 --- a/Con2PrimFactory/src/c2p_report.hxx +++ b/Con2PrimFactory/src/c2p_report.hxx @@ -22,7 +22,6 @@ public: NANS_IN_CONS, ///< One or more evolved variables is NAN/INF RANGE_RHO, ///< Mass density outside EOS range RANGE_EPS, ///< Fluid internal energy outside EOS range - RANGE_KAPPA, ///< Evolved entropy outside EOS range SPEED_LIMIT, ///< Speed limit exceeded RANGE_YE, ///< Electron fraction outside EOS range B_LIMIT, ///< Magnetization above limit @@ -94,9 +93,6 @@ private: /// Specific internal energy \f$ \epsilon \f$. CCTK_REAL eps; - /// Entropy - CCTK_REAL entropy; - /// Velocity. vec vel; @@ -157,14 +153,6 @@ public: eps = eps_; } - CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline void - set_range_entropy(CCTK_REAL entropy_) { - status = RANGE_KAPPA; - set_atmo = false; - adjust_cons = true; // we adjust cons in this case! - entropy = entropy_; - } - CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_speed_limit(vec vel_) { status = SPEED_LIMIT; @@ -247,9 +235,6 @@ public: case RANGE_EPS: printf("Specific energy was out of range! eps readjusted to = %16.8e \n", eps); break; - case RANGE_KAPPA: - printf("Evolved entropy was out of range! entropy readjusted to = %16.8e \n", entropy); - break; case SPEED_LIMIT: printf("Speed limit exceeded, vx, vy, vz = %16.8e, %16.8e, %16.8e \n", vel(0), vel(1), vel(2)); From 560279487323c019ccf8fd6a2110c3ba8021e7f4 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Tue, 5 Nov 2024 15:17:38 -0600 Subject: [PATCH 16/50] Con2PrimFactory: Add entropy inversion to other c2ps --- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 4 ++++ Con2PrimFactory/src/c2p_2DNoble.hxx | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 32b6d7a1..bb61427d 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -190,6 +190,8 @@ c2p_1DPalenzuela::xPalenzuelaToPrim(CCTK_REAL xPalenzuela_Sol, CCTK_REAL Ssq, pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.Bvec = cv.dBvec; const vec Elow = calc_cross_product(pv.Bvec, pv.vel); @@ -393,6 +395,8 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, rep.adjust_cons = true; } + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + // Recompute cons if prims have been adjusted if (rep.adjust_cons) { cv.from_prim(pv, glo); diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 519f19df..fc8abf2b 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -183,6 +183,8 @@ c2p_2DNoble::WZ2Prim(CCTK_REAL Z_Sol, CCTK_REAL vsq_Sol, CCTK_REAL Bsq, pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.Bvec = cv.dBvec; const vec Elow = calc_cross_product(pv.Bvec, pv.vel); @@ -443,6 +445,8 @@ c2p_2DNoble::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, rep.adjust_cons = true; } + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + // Recompute cons if prims have been adjusted if (rep.adjust_cons) { cv.from_prim(pv, glo); From 50b98aa9e65ec65ce1f1b3cc821732ea12134ce6 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 7 Nov 2024 11:10:35 -0600 Subject: [PATCH 17/50] AsterX: Couple properly to entropy inversion --- AsterX/src/con2prim.cxx | 91 ++++++++++++++++++++++++----------------- 1 file changed, 54 insertions(+), 37 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index df7ed983..fc26613c 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -149,6 +149,8 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, pv_seeds.Ye = Ye_atmo; pv_seeds.press = eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); // check on velocities CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); CCTK_REAL vlim_BH = vwlim_BH / wlim_BH; @@ -167,8 +169,8 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, c2p_report rep_second; c2p_report rep_ent; - // Invert entropy here - entropy(p.I) = sstar(p.I)/dens(p.I); + /* set flag to success */ + con2prim_flag(p.I) = 1; // Calling the first C2P switch (c2p_fir) { @@ -203,45 +205,63 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, } } - if (rep_first.failed() && rep_second.failed()) { - printf("Second C2P failed too :( :( \n"); - rep_second.debug_message(); - + if (rep_second.failed()) { if (use_entropy_fix) { + c2p_Ent.solve(eos_th, pv, cv, glo, rep_ent); - } - // Treatment for BH interiors after C2P failures - // NOTE: By default, alp_thresh=0 so the if condition below is never - // triggered. One must be very careful when using this functionality and - // must correctly set alp_thresh, rho_BH, eps_BH and vwlim_BH in the - // parfile - if ((alp(p.I) < alp_thresh) && rep_ent.failed()) { - if ((pv_seeds.rho > rho_BH) || (pv_seeds.eps > eps_BH)) { - pv.rho = rho_BH; // typically set to 0.01% to 1% of rho_max of initial - // NS or disk - pv.eps = eps_BH; - pv.Ye = Ye_atmo; - pv.press = - eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); - // check on velocities - CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); - CCTK_REAL vlim_BH = vwlim_BH / wlim_BH; - CCTK_REAL sol_v = sqrt((pv.w_lor * pv.w_lor - 1.0)) / pv.w_lor; - if (sol_v > vlim_BH) { - pv.vel *= vlim_BH / sol_v; - pv.w_lor = wlim_BH; + if (rep_ent.failed()) { + printf("Entropy C2P failed too :( :( \n"); + rep_ent.debug_message(); + // set to atmo + cv.dBvec(0) = dBx(p.I); + cv.dBvec(1) = dBy(p.I); + cv.dBvec(2) = dBz(p.I); + pv.Bvec = cv.dBvec / sqrt_detg; + atmo.set(pv, cv, glo); + + con2prim_flag(p.I) = 0; + } + + } else { + + printf("Second C2P failed too :( :( \n"); + rep_second.debug_message(); + con2prim_flag(p.I) = 0; + + // Treatment for BH interiors after C2P failures + // NOTE: By default, alp_thresh=0 so the if condition below is never + // triggered. One must be very careful when using this functionality and + // must correctly set alp_thresh, rho_BH, eps_BH and vwlim_BH in the + // parfile + if (alp(p.I) < alp_thresh) { + if ((pv_seeds.rho > rho_BH) || (pv_seeds.eps > eps_BH)) { + pv.rho = rho_BH; // typically set to 0.01% to 1% of rho_max of initial + // NS or disk + pv.eps = eps_BH; + pv.Ye = Ye_atmo; + pv.press = + eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); + // check on velocities + CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); + CCTK_REAL vlim_BH = vwlim_BH / wlim_BH; + CCTK_REAL sol_v = sqrt((pv.w_lor * pv.w_lor - 1.0)) / pv.w_lor; + if (sol_v > vlim_BH) { + pv.vel *= vlim_BH / sol_v; + pv.w_lor = wlim_BH; + } + cv.from_prim(pv, glo); + rep_first.set_atmo = 0; + rep_second.set_atmo = 0; + rep_ent.set_atmo = 0; } - cv.from_prim(pv, glo); - rep_first.set_atmo = 0; - rep_second.set_atmo = 0; - rep_ent.set_atmo = 0; } } - con2prim_flag(p.I) = rep_ent.failed() ? 0 : 1; } - if (rep_first.set_atmo && rep_second.set_atmo && rep_ent.set_atmo) { + if (rep_first.set_atmo && rep_second.set_atmo && !(use_entropy_fix)) { if (debug_mode) { printf( "WARNING: \n" @@ -277,14 +297,11 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, // assert(0); } - /* set flag to success */ - con2prim_flag(p.I) = 1; - // dummy vars CCTK_REAL Ex, Ey, Ez; // Write back pv - pv.scatter(rho(p.I), eps(p.I), dummy_Ye, press(p.I), entropy(p.I),velx(p.I), vely(p.I), + pv.scatter(rho(p.I), eps(p.I), dummy_Ye, press(p.I), entropy(p.I), velx(p.I), vely(p.I), velz(p.I), wlor, Bvecx(p.I), Bvecy(p.I), Bvecz(p.I), Ex, Ey, Ez); zvec_x(p.I) = wlor * pv.vel(0); From ef9849924a54220eab65c91b68c80dc8bd12ad7a Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 7 Nov 2024 11:14:11 -0600 Subject: [PATCH 18/50] AsterX: Minor improvement --- AsterX/src/con2prim.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index fc26613c..b4ede977 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -84,7 +84,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, eps_atm = std::min(std::max(eos_th.rgeps.min, eps_atm), eos_th.rgeps.max); press_atm = eos_th.press_from_valid_rho_eps_ye(rho_atm, eps_atm, Ye_atmo); } - CCTK_REAL kappa_atm = press_atm/pow(rho_atm,gl_gamma); + CCTK_REAL kappa_atm = eos_th.kappa_from_valid_rho_eps_ye(rho_atm, eps_atm, Ye_atmo); atmosphere atmo(rho_atm, eps_atm, Ye_atmo, press_atm, kappa_atm, rho_atmo_cut); // Construct Noble c2p object: From c1353671093d263a462e8fd3bbcaf83877483e7e Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 7 Nov 2024 14:45:38 -0600 Subject: [PATCH 19/50] Con2PrimFactory: Add copy assignment, explicit const keyword, more small changes --- Con2PrimFactory/src/c2p.hxx | 8 ++-- Con2PrimFactory/src/c2p_1DEntropy.hxx | 62 ++++++++++++++++----------- Con2PrimFactory/src/cons.hxx | 15 +++++++ Con2PrimFactory/src/prims.hxx | 18 ++++++++ 4 files changed, 73 insertions(+), 30 deletions(-) diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index 10cac36a..6cfcf470 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -49,15 +49,15 @@ protected: CCTK_REAL cons_error; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Ssq_Exact(vec &mom, + get_Ssq_Exact(const vec &mom, const smat &gup) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Bsq_Exact(vec &B_up, + get_Bsq_Exact(const vec &B_up, const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_BiSi_Exact(vec &Bvec, vec &mom) const; + get_BiSi_Exact(const vec &Bvec, const vec &mom) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec - get_WLorentz_bsq_Seeds(vec &B_up, vec &v_up, + get_WLorentz_bsq_Seeds(const vec &B_up, const vec &v_up, const smat &glo) const; }; diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 56d22dbe..d5fa2fa1 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -13,18 +13,18 @@ public: /* Constructor */ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy( - EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Ssq_Exact(vec &mom, const smat &gup) const; + get_Ssq_Exact(const vec &mom, const smat &gup) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Bsq_Exact(vec &B_up, const smat &glo) const; + get_Bsq_Exact(const vec &B_up, const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_BiSi_Exact(vec &Bvec, vec &mom) const; + get_BiSi_Exact(const vec &Bvec, const vec &mom) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec - get_WLorentz_vsq_bsq_Seeds(vec &B_up, vec &v_up, + get_WLorentz_vsq_bsq_Seeds(const vec &B_up, const vec &v_up, const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan(prim_vars &pv, cons_vars &cv) const; @@ -32,18 +32,18 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, CCTK_REAL Bsq, - CCTK_REAL BiSi, EOSType &eos_th, prim_vars &pv, cons_vars cv, + CCTK_REAL BiSi, const EOSType &eos_th, prim_vars &pv, const cons_vars &cv, const smat &gup, const smat &glo) const; template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, CCTK_REAL x, - EOSType &eos_th, cons_vars &cv) const; + const EOSType &eos_th, const cons_vars &cv) const; template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void - solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, + solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, const smat &glo, c2p_report &rep) const; /* Destructor */ @@ -54,7 +54,7 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( - EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError) { @@ -72,7 +72,7 @@ CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_1DEntropy::get_Ssq_Exact(vec &mom, +c2p_1DEntropy::get_Ssq_Exact(const vec &mom, const smat &gup) const { CCTK_REAL Ssq; @@ -90,7 +90,7 @@ c2p_1DEntropy::get_Ssq_Exact(vec &mom, } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_1DEntropy::get_Bsq_Exact(vec &B_up, +c2p_1DEntropy::get_Bsq_Exact(const vec &B_up, const smat &glo) const { vec B_low = calc_contraction(glo, B_up); @@ -98,15 +98,15 @@ c2p_1DEntropy::get_Bsq_Exact(vec &B_up, } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_1DEntropy::get_BiSi_Exact(vec &Bvec, - vec &mom) const { +c2p_1DEntropy::get_BiSi_Exact(const vec &Bvec, + const vec &mom) const { return Bvec(X) * mom(X) + Bvec(Y) * mom(Y) + Bvec(Z) * mom(Z); // BiSi } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec -c2p_1DEntropy::get_WLorentz_vsq_bsq_Seeds(vec &B_up, - vec &v_up, +c2p_1DEntropy::get_WLorentz_vsq_bsq_Seeds(const vec &B_up, + const vec &v_up, const smat &glo) const { vec v_low = calc_contraction(glo, v_up); CCTK_REAL vsq = calc_contraction(v_low, v_up); @@ -130,8 +130,8 @@ c2p_1DEntropy::get_WLorentz_vsq_bsq_Seeds(vec &B_up, template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, - CCTK_REAL Bsq, CCTK_REAL BiSi, EOSType &eos_th, - prim_vars &pv, cons_vars cv, + CCTK_REAL Bsq, CCTK_REAL BiSi, const EOSType &eos_th, + prim_vars &pv, const cons_vars &cv, const smat &gup, const smat &glo) const { // Density, entropy, Ye @@ -177,8 +177,8 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, - CCTK_REAL x, EOSType &eos_th, - cons_vars &cv) const { + CCTK_REAL x, const EOSType &eos_th, + const cons_vars &cv) const { // We already divided dens, dS and // dYe by sqrt(gamma) @@ -212,7 +212,7 @@ c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void -c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, +c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, const smat &glo, c2p_report &rep) const { ROOTSTAT status = ROOTSTAT::SUCCESS; @@ -247,7 +247,7 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, /* Undensitize the conserved vars */ cv.dens /= sqrt_detg; - // cv.tau /= sqrt_detg; + cv.tau /= sqrt_detg; cv.mom /= sqrt_detg; cv.dBvec /= sqrt_detg; cv.dYe /= sqrt_detg; @@ -347,11 +347,21 @@ c2p_1DEntropy::solve(EOSType &eos_th, prim_vars &pv, cons_vars cv, // check primitives against conservatives cons_vars cv_check; cv_check.from_prim(pv, glo); - CCTK_REAL max_error = sqrt(max({pow(cv_check.dens-cv.dens,2.0)/pow(cv.dens,2.0), - pow(cv_check.mom(0)-cv.mom(0),2.0)/pow(cv.mom(0),2.0), - pow(cv_check.mom(1)-cv.mom(1),2.0)/pow(cv.mom(1),2.0), - pow(cv_check.mom(2)-cv.mom(2),2.0)/pow(cv.mom(2),2.0), - pow(cv_check.tau-cv.tau,2.0)/pow(cv.tau,2.0)})); + /* Undensitize the conserved vars */ + cv_check.dens /= sqrt_detg; + cv_check.tau /= sqrt_detg; + cv_check.mom /= sqrt_detg; + cv_check.dBvec /= sqrt_detg; + cv_check.dYe /= sqrt_detg; + cv_check.dS /= sqrt_detg; + + CCTK_REAL small = 1e-50; + + CCTK_REAL max_error = sqrt(max({pow((cv_check.dens-cv.dens)/(cv.dens+small),2.0), + pow((cv_check.mom(0)-cv.mom(0))/(cv.mom(0)+small),2.0), + pow((cv_check.mom(1)-cv.mom(1))/(cv.mom(1)+small),2.0), + pow((cv_check.mom(2)-cv.mom(2))/(cv.mom(2)+small),2.0), + pow((cv_check.tau-cv.tau)/(cv.tau+small),2.0)})); // reject only if mismatch in conservatives is inappropriate, else accept if (max_error >= cons_error) { diff --git a/Con2PrimFactory/src/cons.hxx b/Con2PrimFactory/src/cons.hxx index d1fc9321..e0c1446f 100644 --- a/Con2PrimFactory/src/cons.hxx +++ b/Con2PrimFactory/src/cons.hxx @@ -29,6 +29,21 @@ struct cons_vars { vec dBvec_) : dens{dens_}, mom{mom_}, tau{tau_}, dYe{dYe_}, dS{dS_}, dBvec{dBvec_} {} + /// Copy assignment + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline cons_vars & + operator=(const cons_vars &other) { + if (this == &other) + return *this; // Handle self-assignment + // Copy data members from 'other' to 'this' + dens = other.dens; + mom = other.mom; + tau = other.tau; + dYe = other.dYe; + dS = other.dS; + dBvec = other.dBvec; + return *this; + } + CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline void from_prim(const prim_vars &pv, const smat &g) { diff --git a/Con2PrimFactory/src/prims.hxx b/Con2PrimFactory/src/prims.hxx index d1eaa83b..843c912b 100644 --- a/Con2PrimFactory/src/prims.hxx +++ b/Con2PrimFactory/src/prims.hxx @@ -32,6 +32,24 @@ struct prim_vars { : rho(rho_), eps(eps_), Ye(ye_), press(press_), kappa(kappa_), vel(vel_), w_lor(w_lor_), Bvec(Bvec_){}; + /// Copy assignment + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline prim_vars & + operator=(const prim_vars &other) { + if (this == &other) + return *this; // Handle self-assignment + // Copy data members from 'other' to 'this' + rho = other.rho; + eps = other.eps; + Ye = other.Ye; + press = other.press; + kappa = other.kappa; + vel = other.vel; + w_lor = other.w_lor; + Bvec = other.Bvec; + E = other.E; + return *this; + } + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void scatter(CCTK_REAL &rho_, CCTK_REAL &eps_, CCTK_REAL &ye_, CCTK_REAL &press_, CCTK_REAL &kappa_, CCTK_REAL &velx_, CCTK_REAL &vely_, CCTK_REAL &velz_, From 8f3978f77aaf334aafc456d013a51deeedca79ad Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 7 Nov 2024 16:48:23 -0600 Subject: [PATCH 20/50] Con2PrimFactory: Consistent changes among all c2ps --- AsterX/src/con2prim.cxx | 6 +- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 316 ++++++++++++++++------- Con2PrimFactory/src/c2p_2DNoble.hxx | 236 +++++++++++------ Con2PrimFactory/src/test.cxx | 3 +- 4 files changed, 392 insertions(+), 169 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index b4ede977..9a0f086b 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -179,7 +179,8 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, break; } case c2p_first_t::Palenzuela: { - c2p_Pal.solve(eos_th, pv, pv_seeds, cv, glo, rep_first); + //c2p_Pal.solve(eos_th, pv, pv_seeds, cv, glo, rep_first); + c2p_Pal.solve(eos_th, pv, cv, glo, rep_first); break; } default: @@ -197,7 +198,8 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, break; } case c2p_second_t::Palenzuela: { - c2p_Pal.solve(eos_th, pv, pv_seeds, cv, glo, rep_second); + //c2p_Pal.solve(eos_th, pv, pv_seeds, cv, glo, rep_second); + c2p_Pal.solve(eos_th, pv, cv, glo, rep_first); break; } default: diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index bb61427d..b6b9dcc2 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -14,21 +14,21 @@ public: /* Constructor */ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela( - EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Ssq_Exact(vec &mom, + get_Ssq_Exact(const vec &mom, const smat &gup) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Bsq_Exact(vec &B_up, + get_Bsq_Exact(const vec &B_up, const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_BiSi_Exact(vec &Bvec, vec &mom) const; + get_BiSi_Exact(const vec &Bvec, const vec &mom) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec - get_WLorentz_vsq_bsq_Seeds(vec &B_up, - vec &v_up, + get_WLorentz_vsq_bsq_Seeds(const vec &B_up, + const vec &v_up, const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan(prim_vars &pv, cons_vars &cv) const; @@ -36,18 +36,18 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void xPalenzuelaToPrim(CCTK_REAL xPalenzuela_Sol, CCTK_REAL Ssq, CCTK_REAL Bsq, - CCTK_REAL BiSi, EOSType &eos_th, prim_vars &pv, - cons_vars cv, const smat &gup, + CCTK_REAL BiSi, const EOSType &eos_th, prim_vars &pv, + const cons_vars &cv, const smat &gup, const smat &glo) const; template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL funcRoot_1DPalenzuela(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, - CCTK_REAL x, EOSType &eos_th, cons_vars &cv) const; + CCTK_REAL x, const EOSType &eos_th, const cons_vars &cv) const; template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void - solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cons_vars cv, + solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, const smat &glo, c2p_report &rep) const; /* Destructor */ @@ -58,7 +58,7 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::c2p_1DPalenzuela( - EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError) { @@ -76,7 +76,7 @@ CCTK_HOST CCTK_DEVICE } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_1DPalenzuela::get_Ssq_Exact(vec &mom, +c2p_1DPalenzuela::get_Ssq_Exact(const vec &mom, const smat &gup) const { CCTK_REAL Ssq; @@ -87,14 +87,14 @@ c2p_1DPalenzuela::get_Ssq_Exact(vec &mom, Ssq += mom(Z) * (gup(X, Z) * mom(X) + gup(Y, Z) * mom(Y) + gup(Z, Z) * mom(Z)); - if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { - Ssq = fabs(Ssq); - } + //if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { + // Ssq = fabs(Ssq); + //} return Ssq; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_1DPalenzuela::get_Bsq_Exact(vec &B_up, +c2p_1DPalenzuela::get_Bsq_Exact(const vec &B_up, const smat &glo) const { vec B_low = calc_contraction(glo, B_up); @@ -102,15 +102,15 @@ c2p_1DPalenzuela::get_Bsq_Exact(vec &B_up, } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_1DPalenzuela::get_BiSi_Exact(vec &Bvec, - vec &mom) const { +c2p_1DPalenzuela::get_BiSi_Exact(const vec &Bvec, + const vec &mom) const { return Bvec(X) * mom(X) + Bvec(Y) * mom(Y) + Bvec(Z) * mom(Z); // BiSi } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec c2p_1DPalenzuela::get_WLorentz_vsq_bsq_Seeds( - vec &B_up, vec &v_up, + const vec &B_up, const vec &v_up, const smat &glo) const { vec v_low = calc_contraction(glo, v_up); CCTK_REAL vsq = calc_contraction(v_low, v_up); @@ -118,9 +118,9 @@ c2p_1DPalenzuela::get_WLorentz_vsq_bsq_Seeds( CCTK_REAL VdotBsq = VdotB * VdotB; CCTK_REAL Bsq = get_Bsq_Exact(B_up, glo); - if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { - vsq = fabs(vsq); - } + //if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { + // vsq = fabs(vsq); + //} CCTK_REAL w_lor = 1. / sqrt(1. - vsq); CCTK_REAL bsq = ((Bsq) / (w_lor * w_lor)) + VdotBsq; @@ -135,8 +135,8 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void c2p_1DPalenzuela::xPalenzuelaToPrim(CCTK_REAL xPalenzuela_Sol, CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, - EOSType &eos_th, prim_vars &pv, - cons_vars cv, const smat &gup, + const EOSType &eos_th, prim_vars &pv, + const cons_vars &cv, const smat &gup, const smat &glo) const { const CCTK_REAL qPalenzuela = cv.tau / cv.dens; const CCTK_REAL rPalenzuela = Ssq / pow(cv.dens, 2); @@ -202,7 +202,7 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL c2p_1DPalenzuela::funcRoot_1DPalenzuela(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, CCTK_REAL x, - EOSType &eos_th, cons_vars &cv) const { + const EOSType &eos_th, const cons_vars &cv) const { // computes f(x) from x and q,r,s,t const CCTK_REAL qPalenzuela = cv.tau / cv.dens; const CCTK_REAL rPalenzuela = Ssq / pow(cv.dens, 2); @@ -236,8 +236,8 @@ c2p_1DPalenzuela::funcRoot_1DPalenzuela(CCTK_REAL Ssq, CCTK_REAL Bsq, template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void -c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, - cons_vars cv, const smat &glo, +c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, + cons_vars &cv, const smat &glo, c2p_report &rep) const { ROOTSTAT status = ROOTSTAT::SUCCESS; @@ -249,11 +249,25 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, /* Check validity of the 3-metric and compute its inverse */ const CCTK_REAL spatial_detg = calc_det(glo); const CCTK_REAL sqrt_detg = sqrt(spatial_detg); - if ((!isfinite(sqrt_detg)) || (sqrt_detg <= 0)) { + //if ((!isfinite(sqrt_detg)) || (sqrt_detg <= 0)) { + // rep.set_invalid_detg(sqrt_detg); + // set_to_nan(pv, cv); + // return; + //} + + // Check positive definiteness of spatial metric + // Sylvester's criterion, see + // https://en.wikipedia.org/wiki/Sylvester%27s_criterion + const bool minor1{ glo(X, X) > 0.0 }; + const bool minor2{ glo(X, X) * glo(Y, Y) - glo(X, Y) * glo(X, Y) > 0.0 }; + const bool minor3{ spatial_detg > 0.0 }; + + if (!(minor1 && minor2 && minor3)) { rep.set_invalid_detg(sqrt_detg); set_to_nan(pv, cv); return; } + const smat gup = calc_inv(glo, spatial_detg); /* Undensitize the conserved vars */ @@ -262,6 +276,7 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cv.mom /= sqrt_detg; cv.dBvec /= sqrt_detg; cv.dYe /= sqrt_detg; + cv.dS /= sqrt_detg; if (cv.dens <= atmo.rho_cut) { rep.set_atmo_set(); @@ -271,29 +286,29 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, // compute primitive B seed from conserved B of current time step for better // guess - pv_seeds.Bvec = cv.dBvec; + // pv_seeds.Bvec = cv.dBvec; const CCTK_REAL Ssq = get_Ssq_Exact(cv.mom, gup); - const CCTK_REAL Bsq = get_Bsq_Exact(pv_seeds.Bvec, glo); - const CCTK_REAL BiSi = get_BiSi_Exact(pv_seeds.Bvec, cv.mom); - const vec w_vsq_bsq = get_WLorentz_vsq_bsq_Seeds( - pv_seeds.Bvec, pv_seeds.vel, glo); // this also recomputes pv_seeds.w_lor - pv_seeds.w_lor = w_vsq_bsq(0); + const CCTK_REAL Bsq = get_Bsq_Exact(cv.dBvec, glo); + const CCTK_REAL BiSi = get_BiSi_Exact(cv.dBvec,cv.mom); + //const vec w_vsq_bsq = get_WLorentz_vsq_bsq_Seeds( + // pv_seeds.Bvec, pv_seeds.vel, glo); // this also recomputes pv_seeds.w_lor + //pv_seeds.w_lor = w_vsq_bsq(0); // CCTK_REAL vsq_seed = w_vsq_bsq(1); // const CCTK_REAL bsq = w_vsq_bsq(2); - if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || - (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { - rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); - set_to_nan(pv, cv); - return; - } + //if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || + // (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { + // rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); + // set_to_nan(pv, cv); + // return; + //} - if (Bsq < 0) { - rep.set_neg_Bsq(Bsq); - set_to_nan(pv, cv); - return; - } + //if (Bsq < 0) { + // rep.set_neg_Bsq(Bsq); + // set_to_nan(pv, cv); + // return; + //} if (Bsq > Bsq_lim) { rep.set_B_limit(Bsq); @@ -304,10 +319,25 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, /* update rho seed from cv and wlor */ // rho consistent with cv.rho should be better guess than rho from last // timestep - pv_seeds.rho = cv.dens / pv_seeds.w_lor; + // pv_seeds.rho = cv.dens / pv_seeds.w_lor; // Find x, this is the recovery process - const CCTK_INT minbits = std::numeric_limits::digits - 4; + //const CCTK_INT minbits = std::numeric_limits::digits - 4; + //const CCTK_INT maxiters = maxIterations; + + // Important! + // Algo::brent terminates if the following accuracy is achieved + // abs(x - y) <= eps * min(abs(x), abs(y)), + // where x and y are the values of the bracket and + // eps = std::ldexp(1, -minbits) = 1 * 2^{-minbits} + // This should probably be changed in Algo::brent + + // We want to set the tolerance to its correct parameter + const CCTK_REAL log2 = std::log(2.0); + const CCTK_INT minbits = int(abs(std::log(tolerance)) / log2); + const CCTK_REAL tolerance_0 = std::ldexp(double(1.0), -minbits); + // Old code: + // const CCTK_INT minbits = std::numeric_limits::digits - 4; const CCTK_INT maxiters = maxIterations; CCTK_REAL qPalenzuela = cv.tau / cv.dens; @@ -321,27 +351,66 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, }; auto result = Algo::brent(fn, a, b, minbits, maxiters, rep.iters); - // Pick best solution - CCTK_REAL xPalenzuela_Sol; - if (abs(fn(result.first)) < abs(fn(result.second))) { - xPalenzuela_Sol = result.first; - } else { - xPalenzuela_Sol = result.second; - } + CCTK_REAL xPalenzuela_Sol = 0.5 * (result.first + result.second); + + //if (abs(fn(result.first)) < abs(fn(result.second))) { + // xPalenzuela_Sol = result.first; + //} else { + // xPalenzuela_Sol = result.second; + //} // Check solution and calculate primitives // TODO:check if to pass result.first or xPalenzuela_Sol - if (rep.iters < maxiters && abs(fn(xPalenzuela_Sol)) < tolerance) { - rep.status = c2p_report::SUCCESS; - status = ROOTSTAT::SUCCESS; - } else { + //if (rep.iters < maxiters && abs(fn(xPalenzuela_Sol)) < tolerance) { + // rep.status = c2p_report::SUCCESS; + // status = ROOTSTAT::SUCCESS; + //} else { // set status to root not converged - rep.set_root_conv(); - status = ROOTSTAT::NOT_CONVERGED; - } + // rep.set_root_conv(); + // status = ROOTSTAT::NOT_CONVERGED; + //} xPalenzuelaToPrim(xPalenzuela_Sol, Ssq, Bsq, BiSi, eos_th, pv, cv, gup, glo); + if (abs(result.first - result.second) > + tolerance_0 * min(abs(result.first), abs(result.second))) { + + // check primitives against conservatives + cons_vars cv_check; + cv_check.from_prim(pv, glo); + /* Undensitize the conserved vars */ + cv_check.dens /= sqrt_detg; + cv_check.tau /= sqrt_detg; + cv_check.mom /= sqrt_detg; + cv_check.dBvec /= sqrt_detg; + cv_check.dYe /= sqrt_detg; + cv_check.dS /= sqrt_detg; + + CCTK_REAL small = 1e-50; + + CCTK_REAL max_error = sqrt(max({pow((cv_check.dens-cv.dens)/(cv.dens+small),2.0), + pow((cv_check.mom(0)-cv.mom(0))/(cv.mom(0)+small),2.0), + pow((cv_check.mom(1)-cv.mom(1))/(cv.mom(1)+small),2.0), + pow((cv_check.mom(2)-cv.mom(2))/(cv.mom(2)+small),2.0), + pow((cv_check.tau-cv.tau)/(cv.tau+small),2.0)})); + + // reject only if mismatch in conservatives is inappropriate, else accept + if (max_error >= cons_error) { + // set status to root not converged + rep.set_root_conv(); + status = ROOTSTAT::NOT_CONVERGED; + return; + } + } + + // Lower velocity + const vec v_low = calc_contraction(glo, pv.vel); + + // ---------- + // Floor and ceiling for rho and velocity + // Keeps pressure the same and changes eps + // ---------- + // set to atmo if computed rho is below floor density if (pv.rho < atmo.rho_cut) { rep.set_atmo_set(); @@ -349,58 +418,121 @@ c2p_1DPalenzuela::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, return; } + // check if computed velocities are within the specified limit + CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); + CCTK_REAL sol_v = sqrt(vsq_Sol); + if (sol_v > v_lim) { + // add mass, keeps conserved density D + pv.rho = cv.dens / w_lim; + pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.vel *= v_lim / sol_v; + pv.w_lor = w_lim; + + rep.adjust_cons = true; + } + + if (pv.rho > rho_strict) { + rep.adjust_cons = true; + // remove mass, changes conserved density D + pv.rho = rho_strict; + pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + } + + // ---------- + // Floor and ceiling for eps + // Keeps rho the same and changes press + // ---------- + // check the validity of the computed eps auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); if (pv.eps > rgeps.max) { - //printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); + rep.adjust_cons = true; - if (pv.rho >= rho_strict) { - rep.set_range_eps(pv.eps); // sets adjust_cons to false by default - rep.adjust_cons = true; - set_to_nan(pv, cv); - return; - } + pv.eps = rgeps.max; + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); } else if (pv.eps < rgeps.min) { + + rep.adjust_cons = true; + pv.eps = rgeps.min; + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + } + + // TODO: check validity for Ye + + // Recompute cons if prims have been adjusted + if (rep.adjust_cons) { + cv.from_prim(pv, glo); + } + + // OLD CODE START + + // set to atmo if computed rho is below floor density + //if (pv.rho < atmo.rho_cut) { + // rep.set_atmo_set(); + // atmo.set(pv, cv, glo); + // return; + //} + + // check the validity of the computed eps + //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); + //if (pv.eps > rgeps.max) { + //printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); + //rep.adjust_cons = true; + //if (pv.rho >= rho_strict) { + //rep.set_range_eps(pv.eps); // sets adjust_cons to false by default + //rep.adjust_cons = true; + //set_to_nan(pv, cv); + //return; + //} + //} else if (pv.eps < rgeps.min) { /* printf( "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e \n", pv.eps, rgeps.min); printf(" Not adjusting cons.. \n"); */ - rep.set_range_eps(rgeps.min); // sets adjust_cons to true - } + //rep.set_range_eps(rgeps.min); // sets adjust_cons to true + //} // TODO: check validity for Ye // check if computed velocities are within the specified limit - vec v_low = calc_contraction(glo, pv.vel); - CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); - CCTK_REAL sol_v = sqrt(vsq_Sol); - if (sol_v > v_lim) { + //vec v_low = calc_contraction(glo, pv.vel); + //CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); + //CCTK_REAL sol_v = sqrt(vsq_Sol); + //if (sol_v > v_lim) { /* printf("(sol_v > v_lim) is true! \n"); printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); */ - pv.rho = cv.dens / w_lim; - if (pv.rho >= rho_strict) { - rep.set_speed_limit({sol_v, sol_v, sol_v}); - set_to_nan(pv, cv); - return; - } - pv.vel *= v_lim / sol_v; - pv.w_lor = w_lim; - pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), eos_th.rgeps.max); - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - - rep.adjust_cons = true; - } - - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.rho = cv.dens / w_lim; + //if (pv.rho >= rho_strict) { + //rep.set_speed_limit({sol_v, sol_v, sol_v}); + //set_to_nan(pv, cv); + //return; + //} + //pv.vel *= v_lim / sol_v; + //pv.w_lor = w_lim; + //pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), eos_th.rgeps.max); + //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + + //rep.adjust_cons = true; + //} + + //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); // Recompute cons if prims have been adjusted - if (rep.adjust_cons) { - cv.from_prim(pv, glo); - } + //if (rep.adjust_cons) { + // cv.from_prim(pv, glo); + //} + + // OLD CODE END } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index fc8abf2b..e499092f 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -15,20 +15,21 @@ public: /* Constructor */ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble( - EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError); + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Ssq_Exact(vec &mom, + get_Ssq_Exact(const vec &mom, const smat &gup) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Bsq_Exact(vec &B_up, + get_Bsq_Exact(const vec &B_up, const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_BiSi_Exact(vec &Bvec, vec &mom) const; + get_BiSi_Exact(const vec &Bvec, const vec &mom) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec - get_WLorentz_vsq_bsq_Seeds(vec &B_up, - vec &v_up, + get_WLorentz_vsq_bsq_Seeds(const vec &B_up, + const vec &v_up, const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan(prim_vars &pv, cons_vars &cv) const; @@ -38,19 +39,19 @@ public: get_Z_Seed(CCTK_REAL rho, CCTK_REAL eps, CCTK_REAL press, CCTK_REAL w_lor) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_Press_funcZVsq(CCTK_REAL Z, CCTK_REAL Vsq, cons_vars &cv) const; + get_Press_funcZVsq(CCTK_REAL Z, CCTK_REAL Vsq, const cons_vars &cv) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_dPdZ_funcZVsq(CCTK_REAL Z, CCTK_REAL Vsq) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL - get_dPdVsq_funcZVsq(CCTK_REAL Z, CCTK_REAL Vsq, cons_vars &cv) const; + get_dPdVsq_funcZVsq(CCTK_REAL Z, CCTK_REAL Vsq, const cons_vars &cv) const; template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void WZ2Prim(CCTK_REAL Z_Sol, CCTK_REAL vsq_Sol, CCTK_REAL Bsq, CCTK_REAL BiSi, - EOSType &eos_th, prim_vars &pv, cons_vars cv, + const EOSType &eos_th, prim_vars &pv, const cons_vars &cv, const smat &gup) const; template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void - solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cons_vars cv, + solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cons_vars &cv, const smat &glo, c2p_report &rep) const; /* Destructor */ @@ -61,7 +62,7 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble::c2p_2DNoble( - EOSType &eos_th, atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError) { @@ -79,33 +80,33 @@ CCTK_HOST } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_2DNoble::get_Ssq_Exact(vec &mom_low, +c2p_2DNoble::get_Ssq_Exact(const vec &mom_low, const smat &gup) const { vec mom_up = calc_contraction(gup, mom_low); CCTK_REAL Ssq = calc_contraction(mom_low, mom_up); - if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { - Ssq = fabs(Ssq); - } + //if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { + // Ssq = fabs(Ssq); + //} return Ssq; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_2DNoble::get_Bsq_Exact(vec &B_up, +c2p_2DNoble::get_Bsq_Exact(const vec &B_up, const smat &glo) const { vec B_low = calc_contraction(glo, B_up); return calc_contraction(B_low, B_up); // Bsq } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL -c2p_2DNoble::get_BiSi_Exact(vec &Bvec, - vec &mom) const { +c2p_2DNoble::get_BiSi_Exact(const vec &Bvec, + const vec &mom) const { return calc_contraction(mom, Bvec); // BiS^i } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec -c2p_2DNoble::get_WLorentz_vsq_bsq_Seeds(vec &B_up, - vec &v_up, +c2p_2DNoble::get_WLorentz_vsq_bsq_Seeds(const vec &B_up, + const vec &v_up, const smat &glo) const { vec v_low = calc_contraction(glo, v_up); CCTK_REAL vsq = calc_contraction(v_low, v_up); @@ -113,9 +114,9 @@ c2p_2DNoble::get_WLorentz_vsq_bsq_Seeds(vec &B_up, CCTK_REAL VdotBsq = VdotB * VdotB; CCTK_REAL Bsq = get_Bsq_Exact(B_up, glo); - if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { - vsq = fabs(vsq); - } + //if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { + // vsq = fabs(vsq); + //} CCTK_REAL w_lor = 1. / sqrt(1. - vsq); CCTK_REAL bsq = ((Bsq) / (w_lor * w_lor)) + VdotBsq; @@ -134,7 +135,7 @@ c2p_2DNoble::get_Z_Seed(CCTK_REAL rho, CCTK_REAL eps, CCTK_REAL press, CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL c2p_2DNoble::get_Press_funcZVsq(CCTK_REAL Z, CCTK_REAL Vsq, - cons_vars &cv) const { + const cons_vars &cv) const { return ((Z * (1.0 - Vsq) - cv.dens * sqrt(1.0 - Vsq)) * (GammaIdealFluid - 1.0) / (GammaIdealFluid)); } @@ -146,7 +147,7 @@ c2p_2DNoble::get_dPdZ_funcZVsq(CCTK_REAL Z, CCTK_REAL Vsq) const { CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL c2p_2DNoble::get_dPdVsq_funcZVsq(CCTK_REAL Z, CCTK_REAL Vsq, - cons_vars &cv) const { + const cons_vars &cv) const { return ((-Z + cv.dens / (2.0 * sqrt(1.0 - Vsq))) * (GammaIdealFluid - 1.0) / GammaIdealFluid); } @@ -154,8 +155,8 @@ c2p_2DNoble::get_dPdVsq_funcZVsq(CCTK_REAL Z, CCTK_REAL Vsq, template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void c2p_2DNoble::WZ2Prim(CCTK_REAL Z_Sol, CCTK_REAL vsq_Sol, CCTK_REAL Bsq, - CCTK_REAL BiSi, EOSType &eos_th, prim_vars &pv, - cons_vars cv, const smat &gup) const { + CCTK_REAL BiSi, const EOSType &eos_th, prim_vars &pv, + const cons_vars &cv, const smat &gup) const { CCTK_REAL W_Sol = 1.0 / sqrt(1.0 - vsq_Sol); pv.rho = cv.dens / W_Sol; @@ -193,8 +194,8 @@ c2p_2DNoble::WZ2Prim(CCTK_REAL Z_Sol, CCTK_REAL vsq_Sol, CCTK_REAL Bsq, template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void -c2p_2DNoble::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, - cons_vars cv, const smat &glo, +c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, + cons_vars &cv, const smat &glo, c2p_report &rep) const { ROOTSTAT status = ROOTSTAT::SUCCESS; @@ -207,11 +208,25 @@ c2p_2DNoble::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, const CCTK_REAL spatial_detg = calc_det(glo); const CCTK_REAL sqrt_detg = sqrt(spatial_detg); - if ((!isfinite(sqrt_detg)) || (sqrt_detg <= 0)) { + //if ((!isfinite(sqrt_detg)) || (sqrt_detg <= 0)) { + // rep.set_invalid_detg(sqrt_detg); + // set_to_nan(pv, cv); + // return; + //} + + // Check positive definiteness of spatial metric + // Sylvester's criterion, see + // https://en.wikipedia.org/wiki/Sylvester%27s_criterion + const bool minor1{ glo(X, X) > 0.0 }; + const bool minor2{ glo(X, X) * glo(Y, Y) - glo(X, Y) * glo(X, Y) > 0.0 }; + const bool minor3{ spatial_detg > 0.0 }; + + if (!(minor1 && minor2 && minor3)) { rep.set_invalid_detg(sqrt_detg); set_to_nan(pv, cv); return; } + const smat gup = calc_inv(glo, spatial_detg); /* Undensitize the conserved vars */ @@ -220,6 +235,7 @@ c2p_2DNoble::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cv.mom /= sqrt_detg; cv.dBvec /= sqrt_detg; cv.dYe /= sqrt_detg; + cv.dS /= sqrt_detg; if (cv.dens <= atmo.rho_cut) { rep.set_atmo_set(); @@ -240,18 +256,18 @@ c2p_2DNoble::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, CCTK_REAL vsq_seed = w_vsq_bsq(1); // const CCTK_REAL bsq = w_vsq_bsq(2); // small b^2 - if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || - (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { - rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); - set_to_nan(pv, cv); - return; - } + //if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || + // (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { + // rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); + // set_to_nan(pv, cv); + // return; + //} - if (Bsq < 0) { - rep.set_neg_Bsq(Bsq); - set_to_nan(pv, cv); - return; - } + //if (Bsq < 0) { + // rep.set_neg_Bsq(Bsq); + // set_to_nan(pv, cv); + // return; + //} if (Bsq > Bsq_lim) { rep.set_B_limit(Bsq); @@ -371,13 +387,20 @@ c2p_2DNoble::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, // storing number of iterations taken to find the root rep.iters = k; - if (fabs(errx) <= tolerance) { - rep.status = c2p_report::SUCCESS; - status = ROOTSTAT::SUCCESS; - } else { + //if (fabs(errx) <= tolerance) { + //rep.status = c2p_report::SUCCESS; + //status = ROOTSTAT::SUCCESS; + //} else { + // set status to root not converged + //rep.set_root_conv(); + //status = ROOTSTAT::NOT_CONVERGED; + //} + + if (fabs(errx) > tolerance) { // set status to root not converged rep.set_root_conv(); status = ROOTSTAT::NOT_CONVERGED; + return; } // Check for bad untrapped divergences @@ -394,6 +417,11 @@ c2p_2DNoble::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, /* Write prims if C2P succeeded */ WZ2Prim(Z_Sol, vsq_Sol, Bsq, BiSi, eos_th, pv, cv, gup); + // ---------- + // Floor and ceiling for rho and velocity + // Keeps pressure the same and changes eps + // ---------- + // set to atmo if computed rho is below floor density if (pv.rho < atmo.rho_cut) { rep.set_atmo_set(); @@ -401,56 +429,116 @@ c2p_2DNoble::solve(EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, return; } + // check if computed velocities are within the specified limit + CCTK_REAL sol_v = sqrt(vsq_Sol); + if (sol_v > v_lim) { + // add mass, keeps conserved density D + pv.rho = cv.dens / w_lim; + pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.vel *= v_lim / sol_v; + pv.w_lor = w_lim; + rep.adjust_cons = true; + } + + if (pv.rho > rho_strict) { + rep.adjust_cons = true; + // remove mass, changes conserved density D + pv.rho = rho_strict; + pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + } + + // ---------- + // Floor and ceiling for eps + // Keeps rho the same and changes press + // ---------- + // check the validity of the computed eps auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); if (pv.eps > rgeps.max) { - //printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); rep.adjust_cons = true; - if (pv.rho >= rho_strict) { - rep.set_range_eps(pv.eps); // sets adjust_cons to false by default - rep.adjust_cons = true; - set_to_nan(pv, cv); - return; - } + pv.eps = rgeps.max; + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); } else if (pv.eps < rgeps.min) { + rep.adjust_cons = true; + pv.eps = rgeps.min; + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + } + + // TODO: check validity for Ye + + // Recompute cons if prims have been adjusted + if (rep.adjust_cons) { + cv.from_prim(pv, glo); + } + + + // START OLD CODE + + // set to atmo if computed rho is below floor density + //if (pv.rho < atmo.rho_cut) { + //rep.set_atmo_set(); + //atmo.set(pv, cv, glo); + //return; + //} + + // check the validity of the computed eps + //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); + //if (pv.eps > rgeps.max) { + //printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); + //rep.adjust_cons = true; + //if (pv.rho >= rho_strict) { + //rep.set_range_eps(pv.eps); // sets adjust_cons to false by default + //rep.adjust_cons = true; + //set_to_nan(pv, cv); + //return; + //} + //} else if (pv.eps < rgeps.min) { /* printf( "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e \n", pv.eps, rgeps.min); printf(" Not adjusting cons.. \n"); */ - rep.set_range_eps(rgeps.min); // sets adjust_cons to true by default - } + //rep.set_range_eps(rgeps.min); // sets adjust_cons to true by default + //} // TODO: check validity for Ye // check if computed velocities are within the specified limit - CCTK_REAL sol_v = sqrt(vsq_Sol); - if (sol_v > v_lim) { + //CCTK_REAL sol_v = sqrt(vsq_Sol); + //if (sol_v > v_lim) { /* printf("(sol_v > v_lim) is true! \n"); printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); */ - pv.rho = cv.dens / w_lim; - if (pv.rho >= rho_strict) { - rep.set_speed_limit({sol_v, sol_v, sol_v}); - set_to_nan(pv, cv); - return; - } - pv.vel *= v_lim / sol_v; - pv.w_lor = w_lim; - pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), eos_th.rgeps.max); - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - - rep.adjust_cons = true; - } - - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.rho = cv.dens / w_lim; + //if (pv.rho >= rho_strict) { + //rep.set_speed_limit({sol_v, sol_v, sol_v}); + //set_to_nan(pv, cv); + //return; + //} + //pv.vel *= v_lim / sol_v; + //pv.w_lor = w_lim; + //pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), eos_th.rgeps.max); + //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + + //rep.adjust_cons = true; + //} + + //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); // Recompute cons if prims have been adjusted - if (rep.adjust_cons) { - cv.from_prim(pv, glo); - } + //if (rep.adjust_cons) { + //cv.from_prim(pv, glo); + //} + + // END OLD CODE } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index 162bb184..2d06e550 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -93,7 +93,8 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { // Testing C2P Palenzuela CCTK_VINFO("Testing C2P Palenzuela..."); - c2p_Pal.solve(eos_th, pv, pv_seeds, cv, g, rep_Pal); + //c2p_Pal.solve(eos_th, pv, pv_seeds, cv, g, rep_Pal); + c2p_Pal.solve(eos_th, pv, cv, g, rep_Pal); printf("pv_seeds, pv: \n" "rho: %f, %f \n" From 52cffed287a76ba5e580910bae7f7bb76ffcd90e Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 8 Nov 2024 14:13:46 -0600 Subject: [PATCH 21/50] Con2PrimFactory: Changes --- AsterX/src/con2prim.cxx | 2 +- Con2PrimFactory/src/c2p_1DEntropy.hxx | 9 +++++++++ Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 8 ++++++++ Con2PrimFactory/src/c2p_2DNoble.hxx | 9 ++++++++- 4 files changed, 26 insertions(+), 2 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 9a0f086b..8a3008b8 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -170,7 +170,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, c2p_report rep_ent; /* set flag to success */ - con2prim_flag(p.I) = 1; + con2prim_flag(p.I) = 1; // Calling the first C2P switch (c2p_fir) { diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index d5fa2fa1..e416fc06 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -470,7 +470,16 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, // Recompute cons if prims have been adjusted if (rep.adjust_cons) { cv.from_prim(pv, glo); + } else { + /* Densitize the conserved vars again*/ + cv.dens *= sqrt_detg; + cv.tau *= sqrt_detg; + cv.mom *= sqrt_detg; + cv.dBvec *= sqrt_detg; + cv.dYe *= sqrt_detg; + cv.dS *= sqrt_detg; } + } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index b6b9dcc2..8215aaed 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -468,6 +468,14 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, // Recompute cons if prims have been adjusted if (rep.adjust_cons) { cv.from_prim(pv, glo); + } else { + /* Densitize the conserved vars again*/ + cv.dens *= sqrt_detg; + cv.tau *= sqrt_detg; + cv.mom *= sqrt_detg; + cv.dBvec *= sqrt_detg; + cv.dYe *= sqrt_detg; + cv.dS *= sqrt_detg; } // OLD CODE START diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index e499092f..78c3edd4 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -475,9 +475,16 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, // Recompute cons if prims have been adjusted if (rep.adjust_cons) { cv.from_prim(pv, glo); + } else { + /* Densitize the conserved vars again*/ + cv.dens *= sqrt_detg; + cv.tau *= sqrt_detg; + cv.mom *= sqrt_detg; + cv.dBvec *= sqrt_detg; + cv.dYe *= sqrt_detg; + cv.dS *= sqrt_detg; } - // START OLD CODE // set to atmo if computed rho is below floor density From 62eff54aa7e04511358186b6fb91af2d151c4ab7 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 8 Nov 2024 15:18:17 -0600 Subject: [PATCH 22/50] Con2PrimFactory: Move limiters to new function --- Con2PrimFactory/src/c2p.hxx | 95 ++++++++++++++++++++++++ Con2PrimFactory/src/c2p_1DEntropy.hxx | 79 +++++++++++--------- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 87 ++++++++++++---------- Con2PrimFactory/src/c2p_2DNoble.hxx | 77 ++++++++++--------- 4 files changed, 230 insertions(+), 108 deletions(-) diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index 6cfcf470..86e27219 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -59,8 +59,103 @@ protected: CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec get_WLorentz_bsq_Seeds(const vec &B_up, const vec &v_up, const smat &glo) const; + + template + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void + prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_vars &cv, + const smat &glo, c2p_report &rep) const; }; +template +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void +c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_vars &cv, + const smat &glo, c2p_report &rep) const { + + //const CCTK_REAL spatial_detg = calc_det(glo); + //const CCTK_REAL sqrt_detg = sqrt(spatial_detg); + + // Lower velocity + const vec v_low = calc_contraction(glo, pv.vel); + + // ---------- + // Floor and ceiling for rho and velocity + // Keeps pressure the same and changes eps + // ---------- + + // check if computed velocities are within the specified limit + CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); + CCTK_REAL sol_v = sqrt(vsq_Sol); + if (sol_v > v_lim) { + /* + printf("(sol_v > v_lim) is true! \n"); + printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); + */ + // add mass, keeps conserved density D + pv.rho = cv.dens / w_lim; + pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + // if (pv.rho >= rho_strict) { + // rep.set_speed_limit({ sol_v, sol_v, sol_v }); + // set_to_nan(pv, cv); + // return; + //} + pv.vel *= v_lim / sol_v; + pv.w_lor = w_lim; + // pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), + // eos_th.rgeps.max); + // pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + + rep.adjust_cons = true; + } + + if (pv.rho > rho_strict) { + rep.adjust_cons = true; + // remove mass, changes conserved density D + pv.rho = rho_strict; + pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); + pv.kappa = + eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + } + + // ---------- + // Floor and ceiling for eps + // Keeps rho the same and changes press + // ---------- + + // check the validity of the computed eps + auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); + if (pv.eps > rgeps.max) { + // printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); + rep.adjust_cons = true; + // if (pv.rho >= rho_strict) { + // rep.set_range_eps(pv.eps); // sets adjust_cons to false by default + // rep.adjust_cons = true; + // set_to_nan(pv, cv); + // return; + //} + pv.eps = rgeps.max; + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + } else if (pv.eps < rgeps.min) { + /* + printf( + "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e + \n", + pv.eps, rgeps.min); + printf(" Not adjusting cons.. \n"); + */ + // rep.set_range_eps(rgeps.min); // sets adjust_cons to true + rep.adjust_cons = true; + pv.eps = rgeps.min; + pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + } + + // TODO: check validity for Ye + +} + } // namespace Con2PrimFactory #endif diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index e416fc06..9655bc4f 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -383,11 +383,6 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, (pv.press + 0.5 * bs2) - bst * bst) - cv.dens; - // ---------- - // Floor and ceiling for rho and velocity - // Keeps pressure the same and changes eps - // ---------- - // set to atmo if computed rho is below floor density if (pv.rho < atmo.rho_cut) { rep.set_atmo_set(); @@ -395,41 +390,55 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, return; } + c2p::prims_floors_and_ceilings(eos_th,pv,cv,glo,rep); + + // ---------- + // Floor and ceiling for rho and velocity + // Keeps pressure the same and changes eps + // ---------- + + // set to atmo if computed rho is below floor density + //if (pv.rho < atmo.rho_cut) { + // rep.set_atmo_set(); + // atmo.set(pv, cv, glo); + // return; + //} + // check if computed velocities are within the specified limit - CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); - CCTK_REAL sol_v = sqrt(vsq_Sol); - if (sol_v > v_lim) { + //CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); + //CCTK_REAL sol_v = sqrt(vsq_Sol); + //if (sol_v > v_lim) { /* printf("(sol_v > v_lim) is true! \n"); printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); */ // add mass, keeps conserved density D - pv.rho = cv.dens / w_lim; - pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); - pv.kappa = - eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.rho = cv.dens / w_lim; + //pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); + //pv.kappa = + // eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); // if (pv.rho >= rho_strict) { // rep.set_speed_limit({ sol_v, sol_v, sol_v }); // set_to_nan(pv, cv); // return; //} - pv.vel *= v_lim / sol_v; - pv.w_lor = w_lim; + //pv.vel *= v_lim / sol_v; + //pv.w_lor = w_lim; // pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), // eos_th.rgeps.max); // pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - rep.adjust_cons = true; - } + //rep.adjust_cons = true; + //} - if (pv.rho > rho_strict) { - rep.adjust_cons = true; + //if (pv.rho > rho_strict) { + //rep.adjust_cons = true; // remove mass, changes conserved density D - pv.rho = rho_strict; - pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); - pv.kappa = - eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); - } + //pv.rho = rho_strict; + //pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); + //pv.kappa = + //eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + //} // ---------- // Floor and ceiling for eps @@ -437,20 +446,20 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, // ---------- // check the validity of the computed eps - auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); - if (pv.eps > rgeps.max) { + //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); + //if (pv.eps > rgeps.max) { // printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); - rep.adjust_cons = true; + //rep.adjust_cons = true; // if (pv.rho >= rho_strict) { // rep.set_range_eps(pv.eps); // sets adjust_cons to false by default // rep.adjust_cons = true; // set_to_nan(pv, cv); // return; //} - pv.eps = rgeps.max; - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - } else if (pv.eps < rgeps.min) { + //pv.eps = rgeps.max; + //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //} else if (pv.eps < rgeps.min) { /* printf( "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e @@ -459,11 +468,11 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, printf(" Not adjusting cons.. \n"); */ // rep.set_range_eps(rgeps.min); // sets adjust_cons to true - rep.adjust_cons = true; - pv.eps = rgeps.min; - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - } + //rep.adjust_cons = true; + //pv.eps = rgeps.min; + //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //} // TODO: check validity for Ye diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 8215aaed..eb9663fb 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -403,8 +403,17 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, } } + // set to atmo if computed rho is below floor density + if (pv.rho < atmo.rho_cut) { + rep.set_atmo_set(); + atmo.set(pv, cv, glo); + return; + } + + c2p::prims_floors_and_ceilings(eos_th,pv,cv,glo,rep); + // Lower velocity - const vec v_low = calc_contraction(glo, pv.vel); + //const vec v_low = calc_contraction(glo, pv.vel); // ---------- // Floor and ceiling for rho and velocity @@ -412,35 +421,35 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, // ---------- // set to atmo if computed rho is below floor density - if (pv.rho < atmo.rho_cut) { - rep.set_atmo_set(); - atmo.set(pv, cv, glo); - return; - } + //if (pv.rho < atmo.rho_cut) { + //rep.set_atmo_set(); + //atmo.set(pv, cv, glo); + //return; + //} // check if computed velocities are within the specified limit - CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); - CCTK_REAL sol_v = sqrt(vsq_Sol); - if (sol_v > v_lim) { + //CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); + //CCTK_REAL sol_v = sqrt(vsq_Sol); + //if (sol_v > v_lim) { // add mass, keeps conserved density D - pv.rho = cv.dens / w_lim; - pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); - pv.kappa = - eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.vel *= v_lim / sol_v; - pv.w_lor = w_lim; - - rep.adjust_cons = true; - } + //pv.rho = cv.dens / w_lim; + //pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); + //pv.kappa = + // eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.vel *= v_lim / sol_v; + //pv.w_lor = w_lim; + + //rep.adjust_cons = true; + //} - if (pv.rho > rho_strict) { - rep.adjust_cons = true; + //if (pv.rho > rho_strict) { + //rep.adjust_cons = true; // remove mass, changes conserved density D - pv.rho = rho_strict; - pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); - pv.kappa = - eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); - } + //pv.rho = rho_strict; + //pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); + //pv.kappa = + //eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + //} // ---------- // Floor and ceiling for eps @@ -448,20 +457,20 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, // ---------- // check the validity of the computed eps - auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); - if (pv.eps > rgeps.max) { - - rep.adjust_cons = true; - pv.eps = rgeps.max; - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - } else if (pv.eps < rgeps.min) { - - rep.adjust_cons = true; - pv.eps = rgeps.min; - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - } + //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); + //if (pv.eps > rgeps.max) { + + //rep.adjust_cons = true; + //pv.eps = rgeps.max; + //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //} else if (pv.eps < rgeps.min) { + + //rep.adjust_cons = true; + //pv.eps = rgeps.min; + //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //} // TODO: check validity for Ye diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 78c3edd4..5cf48d81 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -417,11 +417,6 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, /* Write prims if C2P succeeded */ WZ2Prim(Z_Sol, vsq_Sol, Bsq, BiSi, eos_th, pv, cv, gup); - // ---------- - // Floor and ceiling for rho and velocity - // Keeps pressure the same and changes eps - // ---------- - // set to atmo if computed rho is below floor density if (pv.rho < atmo.rho_cut) { rep.set_atmo_set(); @@ -429,27 +424,41 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, return; } + c2p::prims_floors_and_ceilings(eos_th,pv,cv,glo,rep); + + // ---------- + // Floor and ceiling for rho and velocity + // Keeps pressure the same and changes eps + // ---------- + + // set to atmo if computed rho is below floor density + //if (pv.rho < atmo.rho_cut) { + // rep.set_atmo_set(); + // atmo.set(pv, cv, glo); + // return; + //} + // check if computed velocities are within the specified limit - CCTK_REAL sol_v = sqrt(vsq_Sol); - if (sol_v > v_lim) { + //CCTK_REAL sol_v = sqrt(vsq_Sol); + //if (sol_v > v_lim) { // add mass, keeps conserved density D - pv.rho = cv.dens / w_lim; - pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); - pv.kappa = - eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.vel *= v_lim / sol_v; - pv.w_lor = w_lim; - rep.adjust_cons = true; - } + //pv.rho = cv.dens / w_lim; + //pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); + //pv.kappa = + // eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.vel *= v_lim / sol_v; + //pv.w_lor = w_lim; + //rep.adjust_cons = true; + //} - if (pv.rho > rho_strict) { - rep.adjust_cons = true; + //if (pv.rho > rho_strict) { + //rep.adjust_cons = true; // remove mass, changes conserved density D - pv.rho = rho_strict; - pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); - pv.kappa = - eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); - } + //pv.rho = rho_strict; + //pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); + //pv.kappa = + //eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + //} // ---------- // Floor and ceiling for eps @@ -457,18 +466,18 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, // ---------- // check the validity of the computed eps - auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); - if (pv.eps > rgeps.max) { - rep.adjust_cons = true; - pv.eps = rgeps.max; - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - } else if (pv.eps < rgeps.min) { - rep.adjust_cons = true; - pv.eps = rgeps.min; - pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - } + //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); + //if (pv.eps > rgeps.max) { + //rep.adjust_cons = true; + //pv.eps = rgeps.max; + //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //} else if (pv.eps < rgeps.min) { + //rep.adjust_cons = true; + //pv.eps = rgeps.min; + //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + //} // TODO: check validity for Ye From e5702aa88bda1226cadf0539ff1f40b054aa7590 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 8 Nov 2024 16:13:14 -0600 Subject: [PATCH 23/50] Con2PrimFactory: Clean-up --- AsterX/src/con2prim.cxx | 2 +- Con2PrimFactory/src/c2p_1DEntropy.hxx | 114 +---------------- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 153 +---------------------- Con2PrimFactory/src/c2p_2DNoble.hxx | 132 ------------------- 4 files changed, 3 insertions(+), 398 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 8a3008b8..0eeeba03 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -207,7 +207,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, } } - if (rep_second.failed()) { + if (rep_first.failed() && rep_second.failed()) { if (use_entropy_fix) { c2p_Ent.solve(eos_th, pv, cv, glo, rep_ent); diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 9655bc4f..d5d1174b 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -83,9 +83,6 @@ c2p_1DEntropy::get_Ssq_Exact(const vec &mom, Ssq += mom(Z) * (gup(X, Z) * mom(X) + gup(Y, Z) * mom(Y) + gup(Z, Z) * mom(Z)); - // if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { - // Ssq = fabs(Ssq); - //} return Ssq; } @@ -114,10 +111,6 @@ c2p_1DEntropy::get_WLorentz_vsq_bsq_Seeds(const vec &B_up, CCTK_REAL VdotBsq = VdotB * VdotB; CCTK_REAL Bsq = get_Bsq_Exact(B_up, glo); - // if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { - // vsq = fabs(vsq); - //} - CCTK_REAL w_lor = 1. / sqrt(1. - vsq); CCTK_REAL bsq = ((Bsq) / (w_lor * w_lor)) + VdotBsq; vec w_vsq_bsq{ w_lor, vsq, bsq }; @@ -224,6 +217,7 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, /* Check validity of the 3-metric and compute its inverse */ const CCTK_REAL spatial_detg = calc_det(glo); const CCTK_REAL sqrt_detg = sqrt(spatial_detg); + // if ((!isfinite(sqrt_detg)) || (sqrt_detg <= 0)) { // rep.set_invalid_detg(sqrt_detg); // set_to_nan(pv, cv); @@ -259,19 +253,9 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, return; } - // compute primitive B seed from conserved B of current time step for better - // guess - // pv_seeds.Bvec = cv.dBvec; - const CCTK_REAL Ssq = get_Ssq_Exact(cv.mom, gup); const CCTK_REAL Bsq = get_Bsq_Exact(cv.dBvec, glo); const CCTK_REAL BiSi = get_BiSi_Exact(cv.dBvec, cv.mom); - // const vec w_vsq_bsq = get_WLorentz_vsq_bsq_Seeds( - // pv_seeds.Bvec, pv_seeds.vel, glo); // this also recomputes - // pv_seeds.w_lor - // pv_seeds.w_lor = w_vsq_bsq(0); - // CCTK_REAL vsq_seed = w_vsq_bsq(1); - // const CCTK_REAL bsq = w_vsq_bsq(2); // CHECK // if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || @@ -281,24 +265,12 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, // return; //} - // if (Bsq < 0) { - // rep.set_neg_Bsq(Bsq); - // set_to_nan(pv, cv); - // return; - //} - - // CHECK if (Bsq > Bsq_lim) { rep.set_B_limit(Bsq); set_to_nan(pv, cv); return; } - /* update rho seed from cv and wlor */ - // rho consistent with cv.rho should be better guess than rho from last - // timestep - // pv_seeds.rho = cv.dens / pv_seeds.w_lor; - // See Appendix A.4 of https://arxiv.org/pdf/1112.0568 // Compute (A59) CCTK_REAL a = cv.dens / sqrt(1.0 + Ssq / (cv.dens * cv.dens)); @@ -392,90 +364,6 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, c2p::prims_floors_and_ceilings(eos_th,pv,cv,glo,rep); - // ---------- - // Floor and ceiling for rho and velocity - // Keeps pressure the same and changes eps - // ---------- - - // set to atmo if computed rho is below floor density - //if (pv.rho < atmo.rho_cut) { - // rep.set_atmo_set(); - // atmo.set(pv, cv, glo); - // return; - //} - - // check if computed velocities are within the specified limit - //CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); - //CCTK_REAL sol_v = sqrt(vsq_Sol); - //if (sol_v > v_lim) { - /* - printf("(sol_v > v_lim) is true! \n"); - printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); - */ - // add mass, keeps conserved density D - //pv.rho = cv.dens / w_lim; - //pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); - //pv.kappa = - // eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - // if (pv.rho >= rho_strict) { - // rep.set_speed_limit({ sol_v, sol_v, sol_v }); - // set_to_nan(pv, cv); - // return; - //} - //pv.vel *= v_lim / sol_v; - //pv.w_lor = w_lim; - // pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), - // eos_th.rgeps.max); - // pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - - //rep.adjust_cons = true; - //} - - //if (pv.rho > rho_strict) { - //rep.adjust_cons = true; - // remove mass, changes conserved density D - //pv.rho = rho_strict; - //pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); - //pv.kappa = - //eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); - //} - - // ---------- - // Floor and ceiling for eps - // Keeps rho the same and changes press - // ---------- - - // check the validity of the computed eps - //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); - //if (pv.eps > rgeps.max) { - // printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); - //rep.adjust_cons = true; - // if (pv.rho >= rho_strict) { - // rep.set_range_eps(pv.eps); // sets adjust_cons to false by default - // rep.adjust_cons = true; - // set_to_nan(pv, cv); - // return; - //} - //pv.eps = rgeps.max; - //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //} else if (pv.eps < rgeps.min) { - /* - printf( - "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e - \n", - pv.eps, rgeps.min); - printf(" Not adjusting cons.. \n"); - */ - // rep.set_range_eps(rgeps.min); // sets adjust_cons to true - //rep.adjust_cons = true; - //pv.eps = rgeps.min; - //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //} - - // TODO: check validity for Ye - // Recompute cons if prims have been adjusted if (rep.adjust_cons) { cv.from_prim(pv, glo); diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index eb9663fb..7dcc4b93 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -87,9 +87,6 @@ c2p_1DPalenzuela::get_Ssq_Exact(const vec &mom, Ssq += mom(Z) * (gup(X, Z) * mom(X) + gup(Y, Z) * mom(Y) + gup(Z, Z) * mom(Z)); - //if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { - // Ssq = fabs(Ssq); - //} return Ssq; } @@ -118,10 +115,6 @@ c2p_1DPalenzuela::get_WLorentz_vsq_bsq_Seeds( CCTK_REAL VdotBsq = VdotB * VdotB; CCTK_REAL Bsq = get_Bsq_Exact(B_up, glo); - //if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { - // vsq = fabs(vsq); - //} - CCTK_REAL w_lor = 1. / sqrt(1. - vsq); CCTK_REAL bsq = ((Bsq) / (w_lor * w_lor)) + VdotBsq; vec w_vsq_bsq{w_lor, vsq, bsq}; @@ -249,6 +242,7 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, /* Check validity of the 3-metric and compute its inverse */ const CCTK_REAL spatial_detg = calc_det(glo); const CCTK_REAL sqrt_detg = sqrt(spatial_detg); + //if ((!isfinite(sqrt_detg)) || (sqrt_detg <= 0)) { // rep.set_invalid_detg(sqrt_detg); // set_to_nan(pv, cv); @@ -284,18 +278,9 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, return; } - // compute primitive B seed from conserved B of current time step for better - // guess - // pv_seeds.Bvec = cv.dBvec; - const CCTK_REAL Ssq = get_Ssq_Exact(cv.mom, gup); const CCTK_REAL Bsq = get_Bsq_Exact(cv.dBvec, glo); const CCTK_REAL BiSi = get_BiSi_Exact(cv.dBvec,cv.mom); - //const vec w_vsq_bsq = get_WLorentz_vsq_bsq_Seeds( - // pv_seeds.Bvec, pv_seeds.vel, glo); // this also recomputes pv_seeds.w_lor - //pv_seeds.w_lor = w_vsq_bsq(0); - // CCTK_REAL vsq_seed = w_vsq_bsq(1); - // const CCTK_REAL bsq = w_vsq_bsq(2); //if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || // (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { @@ -304,23 +289,12 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, // return; //} - //if (Bsq < 0) { - // rep.set_neg_Bsq(Bsq); - // set_to_nan(pv, cv); - // return; - //} - if (Bsq > Bsq_lim) { rep.set_B_limit(Bsq); set_to_nan(pv, cv); return; } - /* update rho seed from cv and wlor */ - // rho consistent with cv.rho should be better guess than rho from last - // timestep - // pv_seeds.rho = cv.dens / pv_seeds.w_lor; - // Find x, this is the recovery process //const CCTK_INT minbits = std::numeric_limits::digits - 4; //const CCTK_INT maxiters = maxIterations; @@ -412,68 +386,6 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, c2p::prims_floors_and_ceilings(eos_th,pv,cv,glo,rep); - // Lower velocity - //const vec v_low = calc_contraction(glo, pv.vel); - - // ---------- - // Floor and ceiling for rho and velocity - // Keeps pressure the same and changes eps - // ---------- - - // set to atmo if computed rho is below floor density - //if (pv.rho < atmo.rho_cut) { - //rep.set_atmo_set(); - //atmo.set(pv, cv, glo); - //return; - //} - - // check if computed velocities are within the specified limit - //CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); - //CCTK_REAL sol_v = sqrt(vsq_Sol); - //if (sol_v > v_lim) { - // add mass, keeps conserved density D - //pv.rho = cv.dens / w_lim; - //pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); - //pv.kappa = - // eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //pv.vel *= v_lim / sol_v; - //pv.w_lor = w_lim; - - //rep.adjust_cons = true; - //} - - //if (pv.rho > rho_strict) { - //rep.adjust_cons = true; - // remove mass, changes conserved density D - //pv.rho = rho_strict; - //pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); - //pv.kappa = - //eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); - //} - - // ---------- - // Floor and ceiling for eps - // Keeps rho the same and changes press - // ---------- - - // check the validity of the computed eps - //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); - //if (pv.eps > rgeps.max) { - - //rep.adjust_cons = true; - //pv.eps = rgeps.max; - //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //} else if (pv.eps < rgeps.min) { - - //rep.adjust_cons = true; - //pv.eps = rgeps.min; - //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //} - - // TODO: check validity for Ye - // Recompute cons if prims have been adjusted if (rep.adjust_cons) { cv.from_prim(pv, glo); @@ -487,69 +399,6 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, cv.dS *= sqrt_detg; } - // OLD CODE START - - // set to atmo if computed rho is below floor density - //if (pv.rho < atmo.rho_cut) { - // rep.set_atmo_set(); - // atmo.set(pv, cv, glo); - // return; - //} - - // check the validity of the computed eps - //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); - //if (pv.eps > rgeps.max) { - //printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); - //rep.adjust_cons = true; - //if (pv.rho >= rho_strict) { - //rep.set_range_eps(pv.eps); // sets adjust_cons to false by default - //rep.adjust_cons = true; - //set_to_nan(pv, cv); - //return; - //} - //} else if (pv.eps < rgeps.min) { - /* - printf( - "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e \n", - pv.eps, rgeps.min); - printf(" Not adjusting cons.. \n"); - */ - //rep.set_range_eps(rgeps.min); // sets adjust_cons to true - //} - - // TODO: check validity for Ye - - // check if computed velocities are within the specified limit - //vec v_low = calc_contraction(glo, pv.vel); - //CCTK_REAL vsq_Sol = calc_contraction(v_low, pv.vel); - //CCTK_REAL sol_v = sqrt(vsq_Sol); - //if (sol_v > v_lim) { - /* - printf("(sol_v > v_lim) is true! \n"); - printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); - */ - //pv.rho = cv.dens / w_lim; - //if (pv.rho >= rho_strict) { - //rep.set_speed_limit({sol_v, sol_v, sol_v}); - //set_to_nan(pv, cv); - //return; - //} - //pv.vel *= v_lim / sol_v; - //pv.w_lor = w_lim; - //pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), eos_th.rgeps.max); - //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - - //rep.adjust_cons = true; - //} - - //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - - // Recompute cons if prims have been adjusted - //if (rep.adjust_cons) { - // cv.from_prim(pv, glo); - //} - - // OLD CODE END } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 5cf48d81..3faffe38 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -85,9 +85,6 @@ c2p_2DNoble::get_Ssq_Exact(const vec &mom_low, vec mom_up = calc_contraction(gup, mom_low); CCTK_REAL Ssq = calc_contraction(mom_low, mom_up); - //if ((Ssq < 0.) && (fabs(Ssq) < 1.0e-13)) { - // Ssq = fabs(Ssq); - //} return Ssq; } @@ -114,10 +111,6 @@ c2p_2DNoble::get_WLorentz_vsq_bsq_Seeds(const vec &B_up, CCTK_REAL VdotBsq = VdotB * VdotB; CCTK_REAL Bsq = get_Bsq_Exact(B_up, glo); - //if ((vsq < 0.) && (fabs(vsq) < 1.0e-13)) { - // vsq = fabs(vsq); - //} - CCTK_REAL w_lor = 1. / sqrt(1. - vsq); CCTK_REAL bsq = ((Bsq) / (w_lor * w_lor)) + VdotBsq; vec w_vsq_bsq{w_lor, vsq, bsq}; @@ -254,7 +247,6 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, pv_seeds.Bvec, pv_seeds.vel, glo); // this also recomputes pv_seeds.w_lor pv_seeds.w_lor = w_vsq_bsq(0); CCTK_REAL vsq_seed = w_vsq_bsq(1); - // const CCTK_REAL bsq = w_vsq_bsq(2); // small b^2 //if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || // (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { @@ -263,12 +255,6 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, // return; //} - //if (Bsq < 0) { - // rep.set_neg_Bsq(Bsq); - // set_to_nan(pv, cv); - // return; - //} - if (Bsq > Bsq_lim) { rep.set_B_limit(Bsq); set_to_nan(pv, cv); @@ -298,8 +284,6 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, x[0] = fabs(Z_Seed); x[1] = vsq_seed; - // printf("x[0], x[1]: %f, %f \n", x[0], x[1]); - /* initialize old values */ x_old[0] = x[0]; x_old[1] = x[1]; @@ -426,61 +410,6 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, c2p::prims_floors_and_ceilings(eos_th,pv,cv,glo,rep); - // ---------- - // Floor and ceiling for rho and velocity - // Keeps pressure the same and changes eps - // ---------- - - // set to atmo if computed rho is below floor density - //if (pv.rho < atmo.rho_cut) { - // rep.set_atmo_set(); - // atmo.set(pv, cv, glo); - // return; - //} - - // check if computed velocities are within the specified limit - //CCTK_REAL sol_v = sqrt(vsq_Sol); - //if (sol_v > v_lim) { - // add mass, keeps conserved density D - //pv.rho = cv.dens / w_lim; - //pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); - //pv.kappa = - // eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //pv.vel *= v_lim / sol_v; - //pv.w_lor = w_lim; - //rep.adjust_cons = true; - //} - - //if (pv.rho > rho_strict) { - //rep.adjust_cons = true; - // remove mass, changes conserved density D - //pv.rho = rho_strict; - //pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); - //pv.kappa = - //eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); - //} - - // ---------- - // Floor and ceiling for eps - // Keeps rho the same and changes press - // ---------- - - // check the validity of the computed eps - //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); - //if (pv.eps > rgeps.max) { - //rep.adjust_cons = true; - //pv.eps = rgeps.max; - //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //} else if (pv.eps < rgeps.min) { - //rep.adjust_cons = true; - //pv.eps = rgeps.min; - //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - //} - - // TODO: check validity for Ye - // Recompute cons if prims have been adjusted if (rep.adjust_cons) { cv.from_prim(pv, glo); @@ -494,67 +423,6 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cv.dS *= sqrt_detg; } - // START OLD CODE - - // set to atmo if computed rho is below floor density - //if (pv.rho < atmo.rho_cut) { - //rep.set_atmo_set(); - //atmo.set(pv, cv, glo); - //return; - //} - - // check the validity of the computed eps - //auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); - //if (pv.eps > rgeps.max) { - //printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); - //rep.adjust_cons = true; - //if (pv.rho >= rho_strict) { - //rep.set_range_eps(pv.eps); // sets adjust_cons to false by default - //rep.adjust_cons = true; - //set_to_nan(pv, cv); - //return; - //} - //} else if (pv.eps < rgeps.min) { - /* - printf( - "(pv.eps < rgeps.min) is true! pv.eps, rgeps.min: %26.16e, %26.16e \n", - pv.eps, rgeps.min); - printf(" Not adjusting cons.. \n"); - */ - //rep.set_range_eps(rgeps.min); // sets adjust_cons to true by default - //} - - // TODO: check validity for Ye - - // check if computed velocities are within the specified limit - //CCTK_REAL sol_v = sqrt(vsq_Sol); - //if (sol_v > v_lim) { - /* - printf("(sol_v > v_lim) is true! \n"); - printf("sol_v, v_lim: %26.16e, %26.16e \n", sol_v, v_lim); - */ - //pv.rho = cv.dens / w_lim; - //if (pv.rho >= rho_strict) { - //rep.set_speed_limit({sol_v, sol_v, sol_v}); - //set_to_nan(pv, cv); - //return; - //} - //pv.vel *= v_lim / sol_v; - //pv.w_lor = w_lim; - //pv.eps = std::min(std::max(eos_th.rgeps.min, pv.eps), eos_th.rgeps.max); - //pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - - //rep.adjust_cons = true; - //} - - //pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - - // Recompute cons if prims have been adjusted - //if (rep.adjust_cons) { - //cv.from_prim(pv, glo); - //} - - // END OLD CODE } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void From 5ab9ddb6661175f9947cd5686b9d5fefb61ed6b5 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 8 Nov 2024 16:40:17 -0600 Subject: [PATCH 24/50] AsterX: Small error --- AsterX/src/con2prim.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 0eeeba03..765199b0 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -149,7 +149,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, pv_seeds.Ye = Ye_atmo; pv_seeds.press = eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); - pv.kappa = + pv_seeds.kappa = eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); // check on velocities CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); From f6f9990a1c4dc2dadc811ec5f8d3adda10bcc6ad Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 8 Nov 2024 16:44:36 -0600 Subject: [PATCH 25/50] AsterX: Debug parameter --- AsterX/src/con2prim.cxx | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 765199b0..c1439b00 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -188,9 +188,11 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, } if (rep_first.failed()) { - printf("First C2P failed :( \n"); - rep_first.debug_message(); - printf("Calling the back up C2P.. \n"); + if (debug_mode) { + printf("First C2P failed :( \n"); + rep_first.debug_message(); + printf("Calling the back up C2P.. \n"); + } // Calling the second C2P switch (c2p_sec) { case c2p_second_t::Noble: { From 4f90fbf88ad612220775b70a4208c0590fe1e309 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 8 Nov 2024 16:46:47 -0600 Subject: [PATCH 26/50] AsterX: Remove debug info for c2p inversion --- AsterX/src/con2prim.cxx | 2 -- 1 file changed, 2 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index c1439b00..6b500fea 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -215,8 +215,6 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, c2p_Ent.solve(eos_th, pv, cv, glo, rep_ent); if (rep_ent.failed()) { - printf("Entropy C2P failed too :( :( \n"); - rep_ent.debug_message(); // set to atmo cv.dBvec(0) = dBx(p.I); cv.dBvec(1) = dBy(p.I); From eabfea2f3a42849f1d007afc400dc44dea29a454 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Fri, 8 Nov 2024 16:50:26 -0600 Subject: [PATCH 27/50] AsterX: Further small changes --- AsterX/src/con2prim.cxx | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 6b500fea..fa7929b2 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -227,8 +227,11 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, } else { - printf("Second C2P failed too :( :( \n"); - rep_second.debug_message(); + if (debug_mode) { + printf("Second C2P failed too :( :( \n"); + rep_second.debug_message(); + } + con2prim_flag(p.I) = 0; // Treatment for BH interiors after C2P failures From fe905141e805663ca7ce9c8bee263e1dbc4d98b4 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 11 Nov 2024 11:10:50 -0600 Subject: [PATCH 28/50] Con2PrimFactory: Add option to avoid v>1 in ToPrim --- AsterX/param.ccl | 1 + AsterX/src/con2prim.cxx | 6 +- Con2PrimFactory/param.ccl | 5 ++ Con2PrimFactory/src/c2p.hxx | 1 + Con2PrimFactory/src/c2p_1DEntropy.hxx | 66 +++++++++++++++----- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 68 +++++++++++++++----- Con2PrimFactory/src/c2p_2DNoble.hxx | 79 ++++++++++++++++++------ Con2PrimFactory/src/test.cxx | 4 +- 8 files changed, 177 insertions(+), 53 deletions(-) diff --git a/AsterX/param.ccl b/AsterX/param.ccl index 95929f27..b2f988b6 100644 --- a/AsterX/param.ccl +++ b/AsterX/param.ccl @@ -125,6 +125,7 @@ USES CCTK_REAL rho_BH USES CCTK_REAL eps_BH USES CCTK_REAL vwlim_BH USES CCTK_REAL cons_error_limit +USES BOOLEAN use_z SHARES: ReconX USES KEYWORD reconstruction_method diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index fa7929b2..5bf6465b 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -89,15 +89,15 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, // Construct Noble c2p object: c2p_2DNoble c2p_Noble(eos_th, atmo, max_iter, c2p_tol, rho_strict, vw_lim, - B_lim, Ye_lenient, cons_error_limit); + B_lim, Ye_lenient, cons_error_limit, use_z); // Construct Palenzuela c2p object: c2p_1DPalenzuela c2p_Pal(eos_th, atmo, max_iter, c2p_tol, rho_strict, - vw_lim, B_lim, Ye_lenient, cons_error_limit); + vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z); // Construct Entropy c2p object: c2p_1DEntropy c2p_Ent(eos_th, atmo, max_iter, c2p_tol, rho_strict, - vw_lim, B_lim, Ye_lenient, cons_error_limit); + vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z); /* Get covariant metric */ const smat glo( diff --git a/Con2PrimFactory/param.ccl b/Con2PrimFactory/param.ccl index 77916326..cc598e17 100644 --- a/Con2PrimFactory/param.ccl +++ b/Con2PrimFactory/param.ccl @@ -119,3 +119,8 @@ CCTK_REAL cons_error_limit "Relative deviations in conservatives after c2p fail *:* :: "Negative means always rejection" } 1.0e-3 +# Experimental parameter to use z instead of v to avoid v > 1 + +BOOLEAN use_z "" STEERABLE=ALWAYS +{ +} "no" diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index 86e27219..95ade3a2 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -47,6 +47,7 @@ protected: CCTK_REAL Bsq_lim; atmosphere atmo; CCTK_REAL cons_error; + bool use_zprim; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index d5d1174b..39071b86 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -15,7 +15,8 @@ public: CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError); + CCTK_REAL consError, + bool use_z); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, const smat &gup) const; @@ -56,7 +57,8 @@ CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError) { + CCTK_REAL consError, + bool use_z) { GammaIdealFluid = eos_th.gamma; maxIterations = maxIter; @@ -69,6 +71,7 @@ CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( Bsq_lim = B_lim * B_lim; atmo = atm; cons_error = consError; + use_zprim = use_z; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL @@ -145,20 +148,55 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, CCTK_REAL Z_Sol = (xEntropy_Sol + pv.eps * xEntropy_Sol + pv.press) * pv.w_lor * pv.w_lor; - pv.vel(X) = - (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / - (Z_Sol + Bsq); - pv.vel(X) += BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); + if (use_zprim) { - pv.vel(Y) = - (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / - (Z_Sol + Bsq); - pv.vel(Y) += BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); + CCTK_REAL zx = + pv.w_lor * (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + zx += pv.w_lor * BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); - pv.vel(Z) = - (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / - (Z_Sol + Bsq); - pv.vel(Z) += BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); + CCTK_REAL zy = + pv.w_lor * (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + zy += pv.w_lor * BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); + + CCTK_REAL zz = + pv.w_lor * (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + zz += pv.w_lor * BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); + + CCTK_REAL zx_down = glo(X, X) * zx + glo(X, Y) * zy + glo(X, Z) * zz; + CCTK_REAL zy_down = glo(X, Y) * zx + glo(Y, Y) * zy + glo(Y, Z) * zz; + CCTK_REAL zz_down = glo(X, Z) * zx + glo(Y, Z) * zy + glo(Z, Z) * zz; + + CCTK_REAL Zsq = zx*zx_down + zy*zy_down + zz*zz_down; + + CCTK_REAL SafeLor = sqrt(1.0+Zsq); + + pv.vel(X) = zx/SafeLor; + pv.vel(Y) = zy/SafeLor; + pv.vel(Z) = zz/SafeLor; + + pv.w_lor = SafeLor; + + } else { + + pv.vel(X) = + (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(X) += BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); + + pv.vel(Y) = + (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(Y) += BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); + + pv.vel(Z) = + (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(Z) += BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); + + } pv.Bvec = cv.dBvec; diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 7dcc4b93..7a2699d1 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -16,7 +16,8 @@ public: CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError); + CCTK_REAL consError, + bool use_z); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, @@ -60,7 +61,8 @@ CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::c2p_1DPalenzuela( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError) { + CCTK_REAL consError, + bool use_z) { GammaIdealFluid = eos_th.gamma; maxIterations = maxIter; @@ -73,6 +75,7 @@ CCTK_HOST CCTK_DEVICE Bsq_lim = B_lim * B_lim; atmo = atm; cons_error = consError; + use_zprim = use_z; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL @@ -162,22 +165,57 @@ c2p_1DPalenzuela::xPalenzuelaToPrim(CCTK_REAL xPalenzuela_Sol, CCTK_REAL Ssq, // Taken from WZ2Prim (2DNRNoble) CCTK_REAL Z_Sol = xPalenzuela_Sol * pv.rho * W_sol; - pv.vel(X) = - (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / - (Z_Sol + Bsq); - pv.vel(X) += BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); + if (use_zprim) { - pv.vel(Y) = - (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / - (Z_Sol + Bsq); - pv.vel(Y) += BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); + CCTK_REAL zx = + W_sol * (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + zx += W_sol * BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); - pv.vel(Z) = - (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / - (Z_Sol + Bsq); - pv.vel(Z) += BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); + CCTK_REAL zy = + W_sol * (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + zy += W_sol * BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); - pv.w_lor = W_sol; + CCTK_REAL zz = + W_sol * (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + zz += W_sol * BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); + + CCTK_REAL zx_down = glo(X, X) * zx + glo(X, Y) * zy + glo(X, Z) * zz; + CCTK_REAL zy_down = glo(X, Y) * zx + glo(Y, Y) * zy + glo(Y, Z) * zz; + CCTK_REAL zz_down = glo(X, Z) * zx + glo(Y, Z) * zy + glo(Z, Z) * zz; + + CCTK_REAL Zsq = zx*zx_down + zy*zy_down + zz*zz_down; + + CCTK_REAL SafeLor = sqrt(1.0+Zsq); + + pv.vel(X) = zx/SafeLor; + pv.vel(Y) = zy/SafeLor; + pv.vel(Z) = zz/SafeLor; + + pv.w_lor = SafeLor; + + } else { + + pv.vel(X) = + (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(X) += BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); + + pv.vel(Y) = + (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(Y) += BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); + + pv.vel(Z) = + (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(Z) += BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); + + pv.w_lor = W_sol; + + } pv.Ye = cv.dYe / cv.dens; diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 3faffe38..2fc3bdc8 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -17,7 +17,8 @@ public: CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError); + CCTK_REAL consError, + bool use_z); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, @@ -48,7 +49,8 @@ public: CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void WZ2Prim(CCTK_REAL Z_Sol, CCTK_REAL vsq_Sol, CCTK_REAL Bsq, CCTK_REAL BiSi, const EOSType &eos_th, prim_vars &pv, const cons_vars &cv, - const smat &gup) const; + const smat &gup, + const smat &glo) const; template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cons_vars &cv, @@ -64,7 +66,8 @@ CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble::c2p_2DNoble( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError) { + CCTK_REAL consError, + bool use_z) { GammaIdealFluid = eos_th.gamma; maxIterations = maxIter; @@ -77,6 +80,7 @@ CCTK_HOST Bsq_lim = B_lim * B_lim; atmo = atm; cons_error = consError; + use_zprim = use_z; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL @@ -149,29 +153,66 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void c2p_2DNoble::WZ2Prim(CCTK_REAL Z_Sol, CCTK_REAL vsq_Sol, CCTK_REAL Bsq, CCTK_REAL BiSi, const EOSType &eos_th, prim_vars &pv, - const cons_vars &cv, const smat &gup) const { + const cons_vars &cv, const smat &gup, + const smat &glo) const { CCTK_REAL W_Sol = 1.0 / sqrt(1.0 - vsq_Sol); pv.rho = cv.dens / W_Sol; - pv.vel(X) = - (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / - (Z_Sol + Bsq); - pv.vel(X) += BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); + if (use_zprim) { - pv.vel(Y) = - (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / - (Z_Sol + Bsq); - pv.vel(Y) += BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); + CCTK_REAL zx = + W_Sol * (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + zx += W_Sol * BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); - pv.vel(Z) = - (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / - (Z_Sol + Bsq); - pv.vel(Z) += BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); + CCTK_REAL zy = + W_Sol * (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + zy += W_Sol * BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); - pv.w_lor = W_Sol; + CCTK_REAL zz = + W_Sol * (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + zz += W_Sol * BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); - pv.eps = (Z_Sol * (1. - vsq_Sol) / pv.rho - 1.0) / GammaIdealFluid; + CCTK_REAL zx_down = glo(X, X) * zx + glo(X, Y) * zy + glo(X, Z) * zz; + CCTK_REAL zy_down = glo(X, Y) * zx + glo(Y, Y) * zy + glo(Y, Z) * zz; + CCTK_REAL zz_down = glo(X, Z) * zx + glo(Y, Z) * zy + glo(Z, Z) * zz; + + CCTK_REAL Zsq = zx*zx_down + zy*zy_down + zz*zz_down; + + CCTK_REAL SafeLor = sqrt(1.0+Zsq); + + pv.vel(X) = zx/SafeLor; + pv.vel(Y) = zy/SafeLor; + pv.vel(Z) = zz/SafeLor; + + pv.w_lor = SafeLor; + + } else { + + pv.vel(X) = + (gup(X, X) * cv.mom(X) + gup(X, Y) * cv.mom(Y) + gup(X, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(X) += BiSi * cv.dBvec(X) / (Z_Sol * (Z_Sol + Bsq)); + + pv.vel(Y) = + (gup(X, Y) * cv.mom(X) + gup(Y, Y) * cv.mom(Y) + gup(Y, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(Y) += BiSi * cv.dBvec(Y) / (Z_Sol * (Z_Sol + Bsq)); + + pv.vel(Z) = + (gup(X, Z) * cv.mom(X) + gup(Y, Z) * cv.mom(Y) + gup(Z, Z) * cv.mom(Z)) / + (Z_Sol + Bsq); + pv.vel(Z) += BiSi * cv.dBvec(Z) / (Z_Sol * (Z_Sol + Bsq)); + + pv.w_lor = W_Sol; + + } + + //pv.eps = (Z_Sol * (1. - vsq_Sol) / pv.rho - 1.0) / GammaIdealFluid; + pv.eps = (Z_Sol / pv.w_lor / pv.w_lor / pv.rho - 1.0) / GammaIdealFluid; pv.Ye = cv.dYe / cv.dens; @@ -399,7 +440,7 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, CCTK_REAL vsq_Sol = x[1]; /* Write prims if C2P succeeded */ - WZ2Prim(Z_Sol, vsq_Sol, Bsq, BiSi, eos_th, pv, cv, gup); + WZ2Prim(Z_Sol, vsq_Sol, Bsq, BiSi, eos_th, pv, cv, gup, glo); // set to atmo if computed rho is below floor density if (pv.rho < atmo.rho_cut) { diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index 2d06e550..43ff9218 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -33,8 +33,8 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { 1.0, 0.0, 1.0}; // xx, xy, xz, yy, yz, zz // Con2Prim objects - c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.); - c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.); + c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false); + c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false); // Construct error report object: c2p_report rep_Noble; From e2010d3da09c4b7c66eef79f76ac38844e66f15c Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 11 Nov 2024 15:45:09 -0600 Subject: [PATCH 29/50] AsterX: typo --- AsterX/src/con2prim.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 7d9167b7..004f688e 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -192,6 +192,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, printf("First C2P failed :( \n"); rep_first.debug_message(); printf("Calling the back up C2P.. \n"); + } // Calling the second C2P switch (c2p_sec) { case c2p_second_t::Noble: { From a7c9dfbb03b3659c10378f400121830c6a2b9cff Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Tue, 12 Nov 2024 21:11:48 -0600 Subject: [PATCH 30/50] Con2PrimFactory: Minor changes and bug --- AsterX/src/con2prim.cxx | 8 +++++++- Con2PrimFactory/src/c2p.hxx | 10 +++++++--- Con2PrimFactory/src/c2p_1DEntropy.hxx | 4 ++-- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 4 ++-- Con2PrimFactory/src/c2p_2DNoble.hxx | 4 ++-- 5 files changed, 20 insertions(+), 10 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 004f688e..bdeae19a 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -201,7 +201,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, } case c2p_second_t::Palenzuela: { //c2p_Pal.solve(eos_th, pv, pv_seeds, cv, glo, rep_second); - c2p_Pal.solve(eos_th, pv, cv, glo, rep_first); + c2p_Pal.solve(eos_th, pv, cv, glo, rep_second); break; } default: @@ -216,6 +216,12 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, c2p_Ent.solve(eos_th, pv, cv, glo, rep_ent); if (rep_ent.failed()) { + + if (debug_mode) { + printf("Entropy C2P failed. Setting point to atmosphere.\n"); + rep_ent.debug_message(); + } + // set to atmo cv.dBvec(0) = dBx(p.I); cv.dBvec(1) = dBy(p.I); diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index 95ade3a2..898b6dab 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -111,12 +111,14 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ } if (pv.rho > rho_strict) { - rep.adjust_cons = true; + // remove mass, changes conserved density D pv.rho = rho_strict; pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + + rep.adjust_cons = true; } // ---------- @@ -128,7 +130,6 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ auto rgeps = eos_th.range_eps_from_valid_rho_ye(pv.rho, pv.Ye); if (pv.eps > rgeps.max) { // printf("(pv.eps > rgeps.max) is true, adjusting cons.. \n"); - rep.adjust_cons = true; // if (pv.rho >= rho_strict) { // rep.set_range_eps(pv.eps); // sets adjust_cons to false by default // rep.adjust_cons = true; @@ -138,6 +139,8 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ pv.eps = rgeps.max; pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + + rep.adjust_cons = true; } else if (pv.eps < rgeps.min) { /* printf( @@ -147,10 +150,11 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ printf(" Not adjusting cons.. \n"); */ // rep.set_range_eps(rgeps.min); // sets adjust_cons to true - rep.adjust_cons = true; pv.eps = rgeps.min; pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + + rep.adjust_cons = true; } // TODO: check validity for Ye diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 39071b86..a8f264d9 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -246,7 +246,7 @@ CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, const smat &glo, c2p_report &rep) const { - ROOTSTAT status = ROOTSTAT::SUCCESS; + //ROOTSTAT status = ROOTSTAT::SUCCESS; rep.iters = 0; rep.adjust_cons = false; rep.set_atmo = false; @@ -377,7 +377,7 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, if (max_error >= cons_error) { // set status to root not converged rep.set_root_conv(); - status = ROOTSTAT::NOT_CONVERGED; + //status = ROOTSTAT::NOT_CONVERGED; return; } } diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 7a2699d1..4fe925ee 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -271,7 +271,7 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, const smat &glo, c2p_report &rep) const { - ROOTSTAT status = ROOTSTAT::SUCCESS; + //ROOTSTAT status = ROOTSTAT::SUCCESS; rep.iters = 0; rep.adjust_cons = false; rep.set_atmo = false; @@ -410,7 +410,7 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, if (max_error >= cons_error) { // set status to root not converged rep.set_root_conv(); - status = ROOTSTAT::NOT_CONVERGED; + //status = ROOTSTAT::NOT_CONVERGED; return; } } diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 85a3e588..23799e27 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -232,7 +232,7 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cons_vars &cv, const smat &glo, c2p_report &rep) const { - ROOTSTAT status = ROOTSTAT::SUCCESS; + //ROOTSTAT status = ROOTSTAT::SUCCESS; rep.iters = 0; rep.adjust_cons = false; rep.set_atmo = false; @@ -424,7 +424,7 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, if (fabs(errx) > tolerance) { // set status to root not converged rep.set_root_conv(); - status = ROOTSTAT::NOT_CONVERGED; + //status = ROOTSTAT::NOT_CONVERGED; return; } From 62926db088ca57723517efd2c69cbbae1f3102de Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 18 Nov 2024 11:22:22 -0600 Subject: [PATCH 31/50] Con2PrimFactory: Safety checks and more --- AsterX/src/con2prim.cxx | 28 +++++++- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 6 +- Con2PrimFactory/src/c2p_2DNoble.hxx | 87 ++++++++++++++++++++++-- Con2PrimFactory/src/cons.hxx | 3 +- 4 files changed, 114 insertions(+), 10 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index bdeae19a..5375f201 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -34,6 +34,8 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, DECLARE_CCTK_ARGUMENTSX_AsterX_Con2Prim; DECLARE_CCTK_PARAMETERS; + const bool use_v_vec = CCTK_EQUALS(recon_type, "v_vec"); + c2p_first_t c2p_fir; c2p_second_t c2p_sec; @@ -60,6 +62,10 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, 1, 1, 1>(grid.nghostzones, [=] CCTK_DEVICE( const PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE { + // Note that HydroBaseX gfs are NaN when entering this loop due + // explicit dependence on conservatives from AsterX -> + // dependents tag + // Setting up atmosphere CCTK_REAL rho_atm = 0.0; // dummy initialization CCTK_REAL press_atm = 0.0; // dummy initialization @@ -108,8 +114,22 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, const CCTK_REAL sqrt_detg = sqrt(spatial_detg); vec v_up{saved_velx(p.I), saved_vely(p.I), saved_velz(p.I)}; - const vec v_low = calc_contraction(glo, v_up); - CCTK_REAL wlor = calc_wlorentz(v_low, v_up); + vec v_low = calc_contraction(glo, v_up); + CCTK_REAL zsq{0.0}; + + const CCTK_REAL vsq = calc_contraction(v_low,v_up); + if (vsq >= 1.0) { + CCTK_REAL wlim = sqrt(1.0 + vw_lim * vw_lim); + CCTK_REAL vlim = vw_lim/wlim; + v_up *= vlim/sqrt(vsq); + v_low *= vlim/sqrt(vsq); + zsq = vw_lim; + } else { + zsq = vsq/(1.0-vsq); + } + + //CCTK_REAL wlor = calc_wlorentz(v_low, v_up); + CCTK_REAL wlor = sqrt(1.0+zsq); vec Bup{dBx(p.I) / sqrt_detg, dBy(p.I) / sqrt_detg, dBz(p.I) / sqrt_detg}; @@ -239,6 +259,9 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, rep_second.debug_message(); } + rep_first.set_atmo = true; + rep_second.set_atmo = true; + con2prim_flag(p.I) = 0; // Treatment for BH interiors after C2P failures @@ -337,6 +360,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, saved_vely(p.I) = vely(p.I); saved_velz(p.I) = velz(p.I); saved_eps(p.I) = eps(p.I); + }); // Loop } diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 4fe925ee..a48b5106 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -146,7 +146,7 @@ c2p_1DPalenzuela::xPalenzuelaToPrim(CCTK_REAL xPalenzuela_Sol, CCTK_REAL Ssq, (2.0 * xPalenzuela_Sol + sPalenzuela) * tPalenzuela * tPalenzuela) / (xPalenzuela_Sol * xPalenzuela_Sol * (xPalenzuela_Sol + sPalenzuela) * (xPalenzuela_Sol + sPalenzuela)); - Wminus2 = fmin(fmax(Wminus2, 1e-10), 1 - 1e-10); + Wminus2 = fmin(fmax(Wminus2, 1e-20), 1 - 1e-20); const CCTK_REAL W_sol = pow(Wminus2, -0.5); // (ii) @@ -245,7 +245,7 @@ c2p_1DPalenzuela::funcRoot_1DPalenzuela(CCTK_REAL Ssq, CCTK_REAL Bsq, 1.0 - (x * x * rPalenzuela + (2.0 * x + sPalenzuela) * tPalenzuela * tPalenzuela) / (x * x * (x + sPalenzuela) * (x + sPalenzuela)); - Wminus2 = fmin(fmax(Wminus2, 1e-10), 1 - 1e-10); + Wminus2 = fmin(fmax(Wminus2, 1e-20), 1 - 1e-20); const CCTK_REAL W_loc = pow(Wminus2, -0.5); // (ii) @@ -390,6 +390,7 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, // check primitives against conservatives cons_vars cv_check; cv_check.from_prim(pv, glo); + /* Undensitize the conserved vars */ cv_check.dens /= sqrt_detg; cv_check.tau /= sqrt_detg; @@ -408,6 +409,7 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, // reject only if mismatch in conservatives is inappropriate, else accept if (max_error >= cons_error) { + // set status to root not converged rep.set_root_conv(); //status = ROOTSTAT::NOT_CONVERGED; diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 23799e27..fe7bb2cf 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -11,6 +11,7 @@ class c2p_2DNoble : public c2p { public: /* Some attributes */ CCTK_REAL GammaIdealFluid; + CCTK_REAL Zmin; /* Constructor */ template @@ -32,6 +33,10 @@ public: get_WLorentz_vsq_bsq_Seeds(const vec &B_up, const vec &v_up, const smat &glo) const; + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec + getZ_WLorentz_vsq_bsq_Seeds(const vec &B_up, + const vec &z_up, + const smat &glo) const; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan(prim_vars &pv, cons_vars &cv) const; @@ -81,6 +86,7 @@ CCTK_HOST atmo = atm; cons_error = consError; use_zprim = use_z; + Zmin = eos_th.rgrho.min; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL @@ -122,6 +128,26 @@ c2p_2DNoble::get_WLorentz_vsq_bsq_Seeds(const vec &B_up, return w_vsq_bsq; //{w_lor, vsq, bsq} } +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec +c2p_2DNoble::getZ_WLorentz_vsq_bsq_Seeds(const vec &B_up, + const vec &z_up, + const smat &glo) const { + vec z_low = calc_contraction(glo, z_up); + CCTK_REAL zsq = calc_contraction(z_low, z_up); + + CCTK_REAL w_lor = sqrt(1. + zsq); + CCTK_REAL vsq = min(zsq/w_lor/w_lor,1.-1.e-15); + + CCTK_REAL VdotB = calc_contraction(z_low, B_up)/w_lor; + CCTK_REAL VdotBsq = VdotB * VdotB; + CCTK_REAL Bsq = get_Bsq_Exact(B_up, glo); + + CCTK_REAL bsq = ((Bsq) / (w_lor * w_lor)) + VdotBsq; + vec w_vsq_bsq{w_lor, vsq, bsq}; + + return w_vsq_bsq; //{w_lor, vsq, bsq} +} + /* Called by 2dNRNoble */ CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL @@ -284,10 +310,28 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, const CCTK_REAL Ssq = get_Ssq_Exact(cv.mom, gup); const CCTK_REAL Bsq = get_Bsq_Exact(pv_seeds.Bvec, glo); const CCTK_REAL BiSi = get_BiSi_Exact(pv_seeds.Bvec, cv.mom); - const vec w_vsq_bsq = get_WLorentz_vsq_bsq_Seeds( + + vec w_vsq_bsq; + CCTK_REAL vsq_seed; + + if (use_zprim) { + + vec zvec = pv_seeds.vel*pv_seeds.w_lor; + + w_vsq_bsq = getZ_WLorentz_vsq_bsq_Seeds( + pv_seeds.Bvec, zvec, glo); // this also recomputes pv_seeds.w_lor + + pv_seeds.w_lor = w_vsq_bsq(0); + vsq_seed = w_vsq_bsq(1); + + } else { + + w_vsq_bsq = get_WLorentz_vsq_bsq_Seeds( pv_seeds.Bvec, pv_seeds.vel, glo); // this also recomputes pv_seeds.w_lor - pv_seeds.w_lor = w_vsq_bsq(0); - CCTK_REAL vsq_seed = w_vsq_bsq(1); + + pv_seeds.w_lor = w_vsq_bsq(0); + vsq_seed = w_vsq_bsq(1); + } //if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || // (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { @@ -330,8 +374,14 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, x_old[1] = x[1]; /* Start Recovery with 2D NR Solver */ - const CCTK_INT n = 2; - const CCTK_REAL dv = (1. - 1.e-15); + constexpr CCTK_INT n = 2; + //constexpr CCTK_REAL dv = (1. - 1.e-10);//v_lim*v_lim; //(1. - 1.e-15); + //constexpr CCTK_REAL dw = 1. / (1. - dv);//w_lim*w_lim; + const CCTK_REAL dv = v_lim*v_lim; //(1. - 1.e-15); + const CCTK_REAL dw = w_lim*w_lim; + + + CCTK_REAL dx[n]; CCTK_REAL fjac[n][n]; CCTK_REAL resid[n]; @@ -347,9 +397,29 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, implementation in the Spritz code. As the analytical form of the equations is known, the Newton-Raphson step can be computed explicitly */ + if (x[1] < 0.0) { + x[1] = 0.0; + } + + else { + if (x[1] >= dv) { + x[0] *= dw*(1.0-x[1]); + x[1] = dv; + } + } + + if (x[0] < Zmin) { + x[0] = Zmin; + } else { + if (x[0] > 1e20) { + x[0] = x_old[0]; + } + } + const CCTK_REAL Z = x[0]; const CCTK_REAL invZ = 1.0 / Z; const CCTK_REAL Vsq = x[1]; + const CCTK_REAL Sdotn = -(cv.tau + cv.dens); const CCTK_REAL p_tmp = get_Press_funcZVsq(Z, Vsq, cv); const CCTK_REAL dPdvsq = get_dPdVsq_funcZVsq(Z, Vsq, cv); @@ -390,6 +460,7 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, errx = (x[0] == 0.) ? fabs(dx[0]) : fabs(dx[0] / x[0]); /* make sure that the new x[] is physical */ + /* if (x[0] < 0.0) { x[0] = fabs(x[0]); } else { @@ -407,6 +478,12 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, x[1] = dv; } } + */ + + if (fabs(errx) <= tolerance) { + break; + } + } // storing number of iterations taken to find the root diff --git a/Con2PrimFactory/src/cons.hxx b/Con2PrimFactory/src/cons.hxx index e0c1446f..9a9b43d1 100644 --- a/Con2PrimFactory/src/cons.hxx +++ b/Con2PrimFactory/src/cons.hxx @@ -54,7 +54,8 @@ struct cons_vars { const vec &v_up = pv.vel; const vec v_low = calc_contraction(g, v_up); - const CCTK_REAL w_lorentz = calc_wlorentz(v_low, v_up); + const CCTK_REAL w_lorentz = pv.w_lor;; + //const CCTK_REAL w_lorentz = calc_wlorentz(v_low, v_up); /* Computing B_j */ const vec &B_up = pv.Bvec; From d30ddc4dbe20b9796044f91ed0e03c744ad376f2 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 18 Nov 2024 11:24:14 -0600 Subject: [PATCH 32/50] AsterX: Remove unused bool --- AsterX/src/con2prim.cxx | 2 -- 1 file changed, 2 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 5375f201..4af09a2f 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -34,8 +34,6 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, DECLARE_CCTK_ARGUMENTSX_AsterX_Con2Prim; DECLARE_CCTK_PARAMETERS; - const bool use_v_vec = CCTK_EQUALS(recon_type, "v_vec"); - c2p_first_t c2p_fir; c2p_second_t c2p_sec; From 9ddbd149987c4695200b8e99927d2cde9b7016a0 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 18 Nov 2024 11:28:04 -0600 Subject: [PATCH 33/50] Con2PrimFactory: Readjust hard-coded safety limit --- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index a48b5106..3e2b0008 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -146,7 +146,7 @@ c2p_1DPalenzuela::xPalenzuelaToPrim(CCTK_REAL xPalenzuela_Sol, CCTK_REAL Ssq, (2.0 * xPalenzuela_Sol + sPalenzuela) * tPalenzuela * tPalenzuela) / (xPalenzuela_Sol * xPalenzuela_Sol * (xPalenzuela_Sol + sPalenzuela) * (xPalenzuela_Sol + sPalenzuela)); - Wminus2 = fmin(fmax(Wminus2, 1e-20), 1 - 1e-20); + Wminus2 = fmin(fmax(Wminus2, 1e-10), 1 - 1e-10); const CCTK_REAL W_sol = pow(Wminus2, -0.5); // (ii) @@ -245,7 +245,7 @@ c2p_1DPalenzuela::funcRoot_1DPalenzuela(CCTK_REAL Ssq, CCTK_REAL Bsq, 1.0 - (x * x * rPalenzuela + (2.0 * x + sPalenzuela) * tPalenzuela * tPalenzuela) / (x * x * (x + sPalenzuela) * (x + sPalenzuela)); - Wminus2 = fmin(fmax(Wminus2, 1e-20), 1 - 1e-20); + Wminus2 = fmin(fmax(Wminus2, 1e-10), 1 - 1e-10); const CCTK_REAL W_loc = pow(Wminus2, -0.5); // (ii) From a4cb0ef69825da6d68c9659f1eaed9acb56fe374 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Tue, 19 Nov 2024 08:37:52 -0600 Subject: [PATCH 34/50] EOSX: Lower limit on density --- EOSX/param.ccl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/EOSX/param.ccl b/EOSX/param.ccl index dcee5339..a3ab816e 100644 --- a/EOSX/param.ccl +++ b/EOSX/param.ccl @@ -35,8 +35,8 @@ CCTK_REAL rho_max "Validity region: max density" STEERABLE=RECOVER CCTK_REAL rho_min "Validity region: min density" STEERABLE=RECOVER { - 0:* :: "" -} 0.0 + (0:* :: "" +} 1.0e-20 CCTK_REAL eps_max "Validity region: max internal specific energy" STEERABLE=RECOVER { From 8329bd2b1db603267f060976bcb6183a2e2574d6 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Wed, 20 Nov 2024 14:44:40 -0600 Subject: [PATCH 35/50] Con2PrimFactory: Check for physicality before exiting loop --- Con2PrimFactory/src/c2p_2DNoble.hxx | 62 ++++++++++++++--------------- 1 file changed, 30 insertions(+), 32 deletions(-) diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index fe7bb2cf..2c755467 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -380,8 +380,6 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, const CCTK_REAL dv = v_lim*v_lim; //(1. - 1.e-15); const CCTK_REAL dw = w_lim*w_lim; - - CCTK_REAL dx[n]; CCTK_REAL fjac[n][n]; CCTK_REAL resid[n]; @@ -390,6 +388,26 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, CCTK_REAL df = 1.; CCTK_REAL f = 1.; + /* make sure that x[] is physical */ + if (x[1] < 0.0) { + x[1] = 0.0; + } + + else { + if (x[1] >= dv) { + x[0] *= dw*(1.0-x[1]); + x[1] = dv; + } + } + + if (x[0] < Zmin) { + x[0] = Zmin; + } else { + if (x[0] > 1e20) { + x[0] = x_old[0]; + } + } + CCTK_INT k; for (k = 1; k <= maxIterations; k++) { @@ -397,25 +415,6 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, implementation in the Spritz code. As the analytical form of the equations is known, the Newton-Raphson step can be computed explicitly */ - if (x[1] < 0.0) { - x[1] = 0.0; - } - - else { - if (x[1] >= dv) { - x[0] *= dw*(1.0-x[1]); - x[1] = dv; - } - } - - if (x[0] < Zmin) { - x[0] = Zmin; - } else { - if (x[0] > 1e20) { - x[0] = x_old[0]; - } - } - const CCTK_REAL Z = x[0]; const CCTK_REAL invZ = 1.0 / Z; const CCTK_REAL Vsq = x[1]; @@ -460,25 +459,24 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, errx = (x[0] == 0.) ? fabs(dx[0]) : fabs(dx[0] / x[0]); /* make sure that the new x[] is physical */ - /* - if (x[0] < 0.0) { - x[0] = fabs(x[0]); - } else { - if (x[0] > 1e20) { - x[0] = x_old[0]; - } - } - if (x[1] < 0.0) { x[1] = 0.0; } else { - if (x[1] >= 1.0) { + if (x[1] >= dv) { + x[0] *= dw*(1.0-x[1]); x[1] = dv; } } - */ + + if (x[0] < Zmin) { + x[0] = Zmin; + } else { + if (x[0] > 1e20) { + x[0] = x_old[0]; + } + } if (fabs(errx) <= tolerance) { break; From ad93d01ef1d440543a8fa8e1c1973146c811c564 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Wed, 20 Nov 2024 18:19:03 -0600 Subject: [PATCH 36/50] Con2PrimFactory: Hard-coded c2p limits in Noble --- Con2PrimFactory/src/c2p_2DNoble.hxx | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 78bff101..f6a7bfb6 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -375,10 +375,8 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, /* Start Recovery with 2D NR Solver */ constexpr CCTK_INT n = 2; - //constexpr CCTK_REAL dv = (1. - 1.e-10);//v_lim*v_lim; //(1. - 1.e-15); - //constexpr CCTK_REAL dw = 1. / (1. - dv);//w_lim*w_lim; - const CCTK_REAL dv = v_lim*v_lim; //(1. - 1.e-15); - const CCTK_REAL dw = w_lim*w_lim; + constexpr CCTK_REAL dv = (1. - 1.e-10); + constexpr CCTK_REAL dw = 1. / (1. - dv); CCTK_REAL dx[n]; CCTK_REAL fjac[n][n]; From f4d380f9a7dec0cf14a148368cc7f5a9e38ee42a Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 21 Nov 2024 12:34:30 -0600 Subject: [PATCH 37/50] AsterSeeds: Add entropy initialization to AsterSeeds --- AsterSeeds/param.ccl | 7 ++++++ AsterSeeds/schedule.ccl | 11 ++++++++++ AsterSeeds/src/SetEntropy.cxx | 40 +++++++++++++++++++++++++++++++++++ AsterSeeds/src/make.code.defn | 4 ++-- 4 files changed, 60 insertions(+), 2 deletions(-) create mode 100644 AsterSeeds/src/SetEntropy.cxx diff --git a/AsterSeeds/param.ccl b/AsterSeeds/param.ccl index c5907c53..cfd328d1 100644 --- a/AsterSeeds/param.ccl +++ b/AsterSeeds/param.ccl @@ -149,7 +149,14 @@ REAL dipole_z[2] "z-coordinate of the dipole center" STEERABLE=ALWAYS *:* :: "Anything" } 0.0 +# entropy + +BOOLEAN set_entropy_postinitial "Set the entropy consistently in HydroBaseX_PostInitial" STEERABLE=always +{ +} "yes" + SHARES: EOSX +USES KEYWORD evolution_eos USES CCTK_REAL poly_gamma USES CCTK_REAL poly_k USES CCTK_REAL gl_gamma diff --git a/AsterSeeds/schedule.ccl b/AsterSeeds/schedule.ccl index f07119ec..6bd53885 100644 --- a/AsterSeeds/schedule.ccl +++ b/AsterSeeds/schedule.ccl @@ -91,3 +91,14 @@ if (CCTK_Equals(test_type, "3DTest")) { } } + +#Initial conditions for entropy + +schedule SetEntropy IN HydroBaseX_PostInitial +{ + LANG: C + + READS: HydroBaseX::rho(everywhere) HydroBaseX::eps(everywhere) + WRITES: HydroBaseX::entropy(everywhere) + +} "Set initial entropy" diff --git a/AsterSeeds/src/SetEntropy.cxx b/AsterSeeds/src/SetEntropy.cxx new file mode 100644 index 00000000..8cf1ac0d --- /dev/null +++ b/AsterSeeds/src/SetEntropy.cxx @@ -0,0 +1,40 @@ +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include "eos.hxx" +#include "eos_idealgas.hxx" + +extern "C" void SetEntropy(CCTK_ARGUMENTS) +{ + + using namespace EOSX; + + DECLARE_CCTK_ARGUMENTSX_SetEntropy; + DECLARE_CCTK_PARAMETERS; + + if (set_entropy_postinitial) { + + eos::range rgeps(eps_min, eps_max), rgrho(rho_min, rho_max), + rgye(ye_min, ye_max); + + const eos_idealgas eos_th(gl_gamma, particle_mass, rgeps, rgrho, rgye); + + grid.loop_all_device<1, 1, 1>( + grid.nghostzones, + [=] CCTK_DEVICE(const Loop::PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE { + + entropy(p.I) = eos_th.kappa_from_valid_rho_eps_ye(rho(p.I),eps(p.I),1.0); + + }); + } +} + + diff --git a/AsterSeeds/src/make.code.defn b/AsterSeeds/src/make.code.defn index 864c3f03..cbcfaf32 100644 --- a/AsterSeeds/src/make.code.defn +++ b/AsterSeeds/src/make.code.defn @@ -7,8 +7,8 @@ SRCS = \ 3D_tests.cxx \ atmosphere.cxx \ magTOV.cxx \ - magBNS.cxx - + magBNS.cxx \ + SetEntropy.cxx # Subdirectories containing source files SUBDIRS = From 7f9a1e275882f37ce76fc7eaee9b1aa0be144d39 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 21 Nov 2024 16:10:17 -0600 Subject: [PATCH 38/50] Con2PrimFactory: Default cons_error is not active, include entropy c2p in test --- Con2PrimFactory/param.ccl | 2 +- Con2PrimFactory/src/test.cxx | 91 +++++++++++++++++++++++++++++++----- 2 files changed, 81 insertions(+), 12 deletions(-) diff --git a/Con2PrimFactory/param.ccl b/Con2PrimFactory/param.ccl index cc598e17..da66acad 100644 --- a/Con2PrimFactory/param.ccl +++ b/Con2PrimFactory/param.ccl @@ -117,7 +117,7 @@ CCTK_REAL vwlim_BH " Maximum zvec (v*w) allowed in regions where alp 1 diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index 43ff9218..15cc3df9 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -9,6 +9,7 @@ #include "c2p.hxx" #include "c2p_1DPalenzuela.hxx" #include "c2p_2DNoble.hxx" +#include "c2p_1DEntropy.hxx" #include "c2p_utils.hxx" @@ -25,34 +26,62 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { eos::range rgeps(0, 100), rgrho(1e-13, 20), rgye(0.5, 0.5); const eos_idealgas eos_th(2.0, 938.985, rgeps, rgrho, rgye); + // Set atmo values + const CCTK_REAL rho_atmo = 1e-10; + const CCTK_REAL eps_atmo = 1e-8; + const CCTK_REAL Ye_atmo = 0.5; + const CCTK_REAL press_atmo = eos_th.press_from_valid_rho_eps_ye(rho_atmo,eps_atmo,Ye_atmo); + const CCTK_REAL entropy_atmo = eos_th.kappa_from_valid_rho_eps_ye(rho_atmo,eps_atmo,Ye_atmo); + // Setting up atmosphere - atmosphere atmo(1e-10, 1e-8, 0.5, 1e-8, 1e-10, 0.001); + const CCTK_REAL rho_atmo_cut = rho_atmo * (1 + 1.0e-3); + atmosphere atmo(rho_atmo, eps_atmo, Ye_atmo, press_atmo, entropy_atmo, rho_atmo_cut); // Metric const smat g{1.0, 0.0, 0.0, 1.0, 0.0, 1.0}; // xx, xy, xz, yy, yz, zz // Con2Prim objects + // (eos_th, atmo, max_iter, c2p_tol, rho_strict, + // vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z) c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false); c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false); + c2p_1DEntropy c2p_Ent(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false); // Construct error report object: c2p_report rep_Noble; c2p_report rep_Pal; + c2p_report rep_Ent; + + // Set primitive seeds + const CCTK_REAL rho_in = 0.125; + const CCTK_REAL eps_in = 0.8; + const CCTK_REAL Ye_in = 0.5; + const CCTK_REAL press_in = eos_th.press_from_valid_rho_eps_ye(rho_in,eps_in,Ye_in); + const CCTK_REAL entropy_in = eos_th.kappa_from_valid_rho_eps_ye(rho_in,eps_in,Ye_in); + const vec vup_in = {0.0,0.0,0.0}; + const vec Bup_in = {0.5,-1.0,0.0}; + const vec vdown_in = calc_contraction(g,vup_in); + const CCTK_REAL wlor_in = calc_wlorentz(vdown_in,vup_in); prim_vars pv; - // rho(p.I), eps(p.I), dummy_Ye, press(p.I),v_up, wlor, Bup - prim_vars pv_seeds{0.125, 0.8, 0.5, 0.1, 100,{0, 0, 0}, 1, {0.5, -1.0, 0}}; + // rho(p.I), eps(p.I), dummy_Ye, press(p.I), entropy, v_up, wlor, Bup + prim_vars pv_seeds{rho_in, eps_in, Ye_in, press_in, entropy_in, vup_in, wlor_in, Bup_in}; // cons_vars cv{dens(p.I), {momx(p.I), momy(p.I), momz(p.I)}, tau(p.I), // dummy_dYe, {dBx(p.I), dBy(p.I), dBz(p.I)}}; - cons_vars cv; - cv.from_prim(pv_seeds, g); + cons_vars cv_Noble; + cons_vars cv_Pal; + cons_vars cv_Ent; + + cv_Noble.from_prim(pv_seeds, g); + cv_Pal.from_prim(pv_seeds, g); + cv_Ent.from_prim(pv_seeds, g); // Testing C2P Noble CCTK_VINFO("Testing C2P Noble..."); - c2p_Noble.solve(eos_th, pv, pv_seeds, cv, g, rep_Noble); + c2p_Noble.solve(eos_th, pv, pv_seeds, cv_Noble, g, rep_Noble); printf("pv_seeds, pv: \n" "rho: %f, %f \n" @@ -79,8 +108,8 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "dBx: %f \n" "dBy: %f \n" "dBz: %f \n", - cv.dens, cv.tau, cv.mom(0), cv.mom(1), cv.mom(2), cv.dYe, cv.dBvec(0), - cv.dBvec(1), cv.dBvec(2)); + cv_Noble.dens, cv_Noble.tau, cv_Noble.mom(0), cv_Noble.mom(1), cv_Noble.mom(2), cv_Noble.dYe, cv_Noble.dBvec(0), + cv_Noble.dBvec(1), cv_Noble.dBvec(2)); /* assert(pv.rho == pv_seeds.rho); assert(pv.eps == pv_seeds.eps); @@ -94,7 +123,7 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { // Testing C2P Palenzuela CCTK_VINFO("Testing C2P Palenzuela..."); //c2p_Pal.solve(eos_th, pv, pv_seeds, cv, g, rep_Pal); - c2p_Pal.solve(eos_th, pv, cv, g, rep_Pal); + c2p_Pal.solve(eos_th, pv, cv_Noble, g, rep_Pal); printf("pv_seeds, pv: \n" "rho: %f, %f \n" @@ -121,8 +150,8 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "dBx: %f \n" "dBy: %f \n" "dBz: %f \n", - cv.dens, cv.tau, cv.mom(0), cv.mom(1), cv.mom(2), cv.dYe, cv.dBvec(0), - cv.dBvec(1), cv.dBvec(2)); + cv_Noble.dens, cv_Noble.tau, cv_Noble.mom(0), cv_Noble.mom(1), cv_Noble.mom(2), cv_Noble.dYe, cv_Noble.dBvec(0), + cv_Noble.dBvec(1), cv_Noble.dBvec(2)); /* assert(pv.rho == pv_seeds.rho); assert(pv.eps == pv_seeds.eps); @@ -131,6 +160,46 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { assert(pv.Bvec == pv_seeds.Bvec); */ rep_Pal.debug_message(); + + // Testing C2P Entropy + CCTK_VINFO("Testing C2P Entropy..."); + c2p_Ent.solve(eos_th, pv, cv_Ent, g, rep_Ent); + + printf("pv_seeds, pv: \n" + "rho: %f, %f \n" + "eps: %f, %f \n" + "Ye: %f, %f \n" + "press: %f, %f \n" + "velx: %f, %f \n" + "vely: %f, %f \n" + "velz: %f, %f \n" + "Bx: %f, %f \n" + "By: %f, %f \n" + "Bz: %f, %f \n", + pv_seeds.rho, pv.rho, pv_seeds.eps, pv.eps, pv_seeds.Ye, pv.Ye, + pv_seeds.press, pv.press, pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), + pv.vel(1), pv_seeds.vel(2), pv.vel(2), pv_seeds.Bvec(0), pv.Bvec(0), + pv_seeds.Bvec(1), pv.Bvec(1), pv_seeds.Bvec(2), pv.Bvec(2)); + printf("cv: \n" + "dens: %f \n" + "tau: %f \n" + "momx: %f \n" + "momy: %f \n" + "momz: %f \n" + "dYe: %f \n" + "dBx: %f \n" + "dBy: %f \n" + "dBz: %f \n", + cv_Ent.dens, cv_Ent.tau, cv_Ent.mom(0), cv_Ent.mom(1), cv_Ent.mom(2), cv_Ent.dYe, cv_Ent.dBvec(0), + cv_Ent.dBvec(1), cv_Ent.dBvec(2)); + /* + assert(pv.rho == pv_seeds.rho); + assert(pv.eps == pv_seeds.eps); + assert(pv.press == pv_seeds.press); + assert(pv.vel == pv_seeds.vel); + assert(pv.Bvec == pv_seeds.Bvec); + */ + rep_Ent.debug_message(); } } // namespace Con2PrimFactory From 88f38862b6bc9f2bb0215042102c93103cba352e Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 21 Nov 2024 21:30:21 -0600 Subject: [PATCH 39/50] Con2PrimFactory: NaN checks, C2P unit test --- Con2PrimFactory/src/c2p_1DEntropy.hxx | 14 ++++---- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 13 +++---- Con2PrimFactory/src/c2p_2DNoble.hxx | 13 +++---- Con2PrimFactory/src/test.cxx | 46 ++++++++++++++++-------- 4 files changed, 52 insertions(+), 34 deletions(-) diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index a8f264d9..a5bc21fc 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -295,13 +295,13 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, const CCTK_REAL Bsq = get_Bsq_Exact(cv.dBvec, glo); const CCTK_REAL BiSi = get_BiSi_Exact(cv.dBvec, cv.mom); - // CHECK - // if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || - // (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { - // rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); - // set_to_nan(pv, cv); - // return; - //} + // TODO: Is this check really necessary? + if ( isfinite(cv.dens) || isfinite(Ssq) || isfinite(Bsq) || + isfinite(BiSi) || isfinite(cv.dYe) || isfinite(cv.dS) ) { + rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); + set_to_nan(pv, cv); + return; + } if (Bsq > Bsq_lim) { rep.set_B_limit(Bsq); diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 5d055104..cbf8d958 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -320,12 +320,13 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, const CCTK_REAL Bsq = get_Bsq_Exact(cv.dBvec, glo); const CCTK_REAL BiSi = get_BiSi_Exact(cv.dBvec,cv.mom); - //if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || - // (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { - // rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); - // set_to_nan(pv, cv); - // return; - //} + // TODO: Is this check really necessary? + if ( isfinite(cv.dens) || isfinite(Ssq) || isfinite(Bsq) || + isfinite(BiSi) || isfinite(cv.dYe) || isfinite(cv.dS) ) { + rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); + set_to_nan(pv, cv); + return; + } if (Bsq > Bsq_lim) { rep.set_B_limit(Bsq); diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index f6a7bfb6..8366d7c9 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -333,12 +333,13 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, vsq_seed = w_vsq_bsq(1); } - //if ((!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || - // (!isfinite(BiSi)) || (!isfinite(cv.dYe))) { - // rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); - // set_to_nan(pv, cv); - // return; - //} + // TODO: Is this check really necessary? + if ( isfinite(cv.dens) || isfinite(Ssq) || isfinite(Bsq) || + isfinite(BiSi) || isfinite(cv.dYe) || isfinite(cv.dS) ) { + rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); + set_to_nan(pv, cv); + return; + } if (Bsq > Bsq_lim) { rep.set_B_limit(Bsq); diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index 15cc3df9..46f9b383 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -74,20 +74,28 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { cons_vars cv_Noble; cons_vars cv_Pal; cons_vars cv_Ent; + cons_vars cv_all; + // C2P solve may modify cons_vars input + // Use the following to test C2Ps independently cv_Noble.from_prim(pv_seeds, g); cv_Pal.from_prim(pv_seeds, g); cv_Ent.from_prim(pv_seeds, g); + // Use the following to test C2Ps in sequence + // (As done in AsterX, the evolution thorn) + cv_all.from_prim(pv_seeds, g); + // Testing C2P Noble CCTK_VINFO("Testing C2P Noble..."); - c2p_Noble.solve(eos_th, pv, pv_seeds, cv_Noble, g, rep_Noble); + c2p_Noble.solve(eos_th, pv, pv_seeds, cv_all, g, rep_Noble); printf("pv_seeds, pv: \n" "rho: %f, %f \n" "eps: %f, %f \n" "Ye: %f, %f \n" "press: %f, %f \n" + "entropy: %f, %f \n" "velx: %f, %f \n" "vely: %f, %f \n" "velz: %f, %f \n" @@ -95,7 +103,8 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "By: %f, %f \n" "Bz: %f, %f \n", pv_seeds.rho, pv.rho, pv_seeds.eps, pv.eps, pv_seeds.Ye, pv.Ye, - pv_seeds.press, pv.press, pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), + pv_seeds.press, pv.press, pv_seeds.kappa, pv.kappa, + pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), pv.vel(1), pv_seeds.vel(2), pv.vel(2), pv_seeds.Bvec(0), pv.Bvec(0), pv_seeds.Bvec(1), pv.Bvec(1), pv_seeds.Bvec(2), pv.Bvec(2)); printf("cv: \n" @@ -107,9 +116,10 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "dYe: %f \n" "dBx: %f \n" "dBy: %f \n" - "dBz: %f \n", - cv_Noble.dens, cv_Noble.tau, cv_Noble.mom(0), cv_Noble.mom(1), cv_Noble.mom(2), cv_Noble.dYe, cv_Noble.dBvec(0), - cv_Noble.dBvec(1), cv_Noble.dBvec(2)); + "dBz: %f \n" + "dS: %f \n", + cv_all.dens, cv_all.tau, cv_all.mom(0), cv_all.mom(1), cv_all.mom(2), cv_all.dYe, cv_all.dBvec(0), + cv_all.dBvec(1), cv_all.dBvec(2), cv_all.dS); /* assert(pv.rho == pv_seeds.rho); assert(pv.eps == pv_seeds.eps); @@ -123,13 +133,14 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { // Testing C2P Palenzuela CCTK_VINFO("Testing C2P Palenzuela..."); //c2p_Pal.solve(eos_th, pv, pv_seeds, cv, g, rep_Pal); - c2p_Pal.solve(eos_th, pv, cv_Noble, g, rep_Pal); + c2p_Pal.solve(eos_th, pv, cv_all, g, rep_Pal); printf("pv_seeds, pv: \n" "rho: %f, %f \n" "eps: %f, %f \n" "Ye: %f, %f \n" "press: %f, %f \n" + "entropy: %f, %f \n" "velx: %f, %f \n" "vely: %f, %f \n" "velz: %f, %f \n" @@ -137,7 +148,8 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "By: %f, %f \n" "Bz: %f, %f \n", pv_seeds.rho, pv.rho, pv_seeds.eps, pv.eps, pv_seeds.Ye, pv.Ye, - pv_seeds.press, pv.press, pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), + pv_seeds.press, pv.press, pv_seeds.kappa, pv.kappa, + pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), pv.vel(1), pv_seeds.vel(2), pv.vel(2), pv_seeds.Bvec(0), pv.Bvec(0), pv_seeds.Bvec(1), pv.Bvec(1), pv_seeds.Bvec(2), pv.Bvec(2)); printf("cv: \n" @@ -149,9 +161,10 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "dYe: %f \n" "dBx: %f \n" "dBy: %f \n" - "dBz: %f \n", - cv_Noble.dens, cv_Noble.tau, cv_Noble.mom(0), cv_Noble.mom(1), cv_Noble.mom(2), cv_Noble.dYe, cv_Noble.dBvec(0), - cv_Noble.dBvec(1), cv_Noble.dBvec(2)); + "dBz: %f \n" + "dS: %f \n", + cv_all.dens, cv_all.tau, cv_all.mom(0), cv_all.mom(1), cv_all.mom(2), cv_all.dYe, cv_all.dBvec(0), + cv_all.dBvec(1), cv_all.dBvec(2), cv_all.dS); /* assert(pv.rho == pv_seeds.rho); assert(pv.eps == pv_seeds.eps); @@ -163,13 +176,14 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { // Testing C2P Entropy CCTK_VINFO("Testing C2P Entropy..."); - c2p_Ent.solve(eos_th, pv, cv_Ent, g, rep_Ent); + c2p_Ent.solve(eos_th, pv, cv_all, g, rep_Ent); printf("pv_seeds, pv: \n" "rho: %f, %f \n" "eps: %f, %f \n" "Ye: %f, %f \n" "press: %f, %f \n" + "entropy: %f, %f \n" "velx: %f, %f \n" "vely: %f, %f \n" "velz: %f, %f \n" @@ -177,7 +191,8 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "By: %f, %f \n" "Bz: %f, %f \n", pv_seeds.rho, pv.rho, pv_seeds.eps, pv.eps, pv_seeds.Ye, pv.Ye, - pv_seeds.press, pv.press, pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), + pv_seeds.press, pv.press, pv_seeds.kappa, pv.kappa, + pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), pv.vel(1), pv_seeds.vel(2), pv.vel(2), pv_seeds.Bvec(0), pv.Bvec(0), pv_seeds.Bvec(1), pv.Bvec(1), pv_seeds.Bvec(2), pv.Bvec(2)); printf("cv: \n" @@ -189,9 +204,10 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "dYe: %f \n" "dBx: %f \n" "dBy: %f \n" - "dBz: %f \n", - cv_Ent.dens, cv_Ent.tau, cv_Ent.mom(0), cv_Ent.mom(1), cv_Ent.mom(2), cv_Ent.dYe, cv_Ent.dBvec(0), - cv_Ent.dBvec(1), cv_Ent.dBvec(2)); + "dBz: %f \n" + "dS: %f \n", + cv_all.dens, cv_all.tau, cv_all.mom(0), cv_all.mom(1), cv_all.mom(2), cv_all.dYe, cv_all.dBvec(0), + cv_all.dBvec(1), cv_all.dBvec(2), cv_all.dS); /* assert(pv.rho == pv_seeds.rho); assert(pv.eps == pv_seeds.eps); From 800bda46a05fcb07af559df3ddc4292c7af12e5d Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Thu, 21 Nov 2024 21:34:17 -0600 Subject: [PATCH 40/50] Con2PrimFactory: Typo --- Con2PrimFactory/src/c2p_1DEntropy.hxx | 4 ++-- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 4 ++-- Con2PrimFactory/src/c2p_2DNoble.hxx | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index a5bc21fc..0aef02d5 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -296,8 +296,8 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, const CCTK_REAL BiSi = get_BiSi_Exact(cv.dBvec, cv.mom); // TODO: Is this check really necessary? - if ( isfinite(cv.dens) || isfinite(Ssq) || isfinite(Bsq) || - isfinite(BiSi) || isfinite(cv.dYe) || isfinite(cv.dS) ) { + if ( (!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || + (!isfinite(BiSi)) || (!isfinite(cv.dYe)) || (!isfinite(cv.dS)) ) { rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); set_to_nan(pv, cv); return; diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index cbf8d958..91673ef8 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -321,8 +321,8 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, const CCTK_REAL BiSi = get_BiSi_Exact(cv.dBvec,cv.mom); // TODO: Is this check really necessary? - if ( isfinite(cv.dens) || isfinite(Ssq) || isfinite(Bsq) || - isfinite(BiSi) || isfinite(cv.dYe) || isfinite(cv.dS) ) { + if ( (!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || + (!isfinite(BiSi)) || (!isfinite(cv.dYe)) || (!isfinite(cv.dS)) ) { rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); set_to_nan(pv, cv); return; diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 8366d7c9..a345e7b1 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -334,8 +334,8 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, } // TODO: Is this check really necessary? - if ( isfinite(cv.dens) || isfinite(Ssq) || isfinite(Bsq) || - isfinite(BiSi) || isfinite(cv.dYe) || isfinite(cv.dS) ) { + if ( (!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || + (!isfinite(BiSi)) || (!isfinite(cv.dYe)) || (!isfinite(cv.dS)) ) { rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); set_to_nan(pv, cv); return; From 5046dec7086abbf754b39ed2638eb5f21e228f31 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 25 Nov 2024 10:44:12 -0600 Subject: [PATCH 41/50] AsterX: Comments and consistent use of entropy and kappa --- AsterX/interface.ccl | 10 ++++++++++ AsterX/src/con2prim.cxx | 8 ++++---- Con2PrimFactory/src/atmo.hxx | 12 ++++++------ Con2PrimFactory/src/c2p.hxx | 8 ++++---- Con2PrimFactory/src/c2p_1DEntropy.hxx | 6 +++--- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 2 +- Con2PrimFactory/src/c2p_2DNoble.hxx | 2 +- Con2PrimFactory/src/cons.hxx | 2 +- Con2PrimFactory/src/prims.hxx | 23 ++++++++++++++++------- Con2PrimFactory/src/test.cxx | 6 +++--- EOSX/src/eos_idealgas.hxx | 14 ++++++++++++++ 11 files changed, 63 insertions(+), 30 deletions(-) diff --git a/AsterX/interface.ccl b/AsterX/interface.ccl index ff13f609..6f1d2c37 100644 --- a/AsterX/interface.ccl +++ b/AsterX/interface.ccl @@ -23,6 +23,16 @@ CCTK_REAL mom TYPE=gf CENTERING={ccc} TAGS='rhs="momrhs" dependents="HydroBaseX: CCTK_REAL tau TYPE=gf CENTERING={ccc} TAGS='rhs="taurhs" dependents="HydroBaseX::eps HydroBaseX::press HydroBaseX::temperature HydroBaseX::Ye HydroBaseX::Bvec TmunuBaseX::eTij"' "Conserved internal energy density" +# sstar is the conserved "evolved" entropy. +# The corresponding primitive is stored in HydroBaseX::entropy. +# However, note that this gf stores the "evolved" entropy which is +# not necessarily the "physical" entropy. This depends on the EOS, e.g. +# for the ideal gas we have entropy = p rho^(-gamma). +# The distinction between "evolved" and "physical" entropy is made +# explicit in EOSX where functions with "entropy_..." and "kappa_..." +# refer to "physical" and "evolved" entropy, respectively. In this +# evolution thorn we always refer to sstar and entropy to describe +# the "evolved" quantities. CCTK_REAL sstar TYPE=gf CENTERING={ccc} TAGS='rhs="sstarrhs" dependents="HydroBaseX::entropy AsterX::flux_x AsterX::flux_y AsterX::flux_z"' "Advected entropy density" CCTK_REAL flux_x TYPE=gf CENTERING={vcc} TAGS='checkpoint="no"' diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 4af09a2f..7b8113d6 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -88,8 +88,8 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, eps_atm = std::min(std::max(eos_th.rgeps.min, eps_atm), eos_th.rgeps.max); press_atm = eos_th.press_from_valid_rho_eps_ye(rho_atm, eps_atm, Ye_atmo); } - CCTK_REAL kappa_atm = eos_th.kappa_from_valid_rho_eps_ye(rho_atm, eps_atm, Ye_atmo); - atmosphere atmo(rho_atm, eps_atm, Ye_atmo, press_atm, kappa_atm, rho_atmo_cut); + CCTK_REAL entropy_atm = eos_th.kappa_from_valid_rho_eps_ye(rho_atm, eps_atm, Ye_atmo); + atmosphere atmo(rho_atm, eps_atm, Ye_atmo, press_atm, entropy_atm, rho_atmo_cut); // Construct Noble c2p object: c2p_2DNoble c2p_Noble(eos_th, atmo, max_iter, c2p_tol, rho_strict, vw_lim, @@ -167,7 +167,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, pv_seeds.Ye = Ye_atmo; pv_seeds.press = eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); - pv_seeds.kappa = + pv_seeds.entropy = eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); // check on velocities CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); @@ -275,7 +275,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, pv.Ye = Ye_atmo; pv.press = eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); - pv.kappa = + pv.entropy = eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); // check on velocities CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); diff --git a/Con2PrimFactory/src/atmo.hxx b/Con2PrimFactory/src/atmo.hxx index 98de509d..551cce54 100644 --- a/Con2PrimFactory/src/atmo.hxx +++ b/Con2PrimFactory/src/atmo.hxx @@ -18,16 +18,16 @@ struct atmosphere { CCTK_REAL eps_atmo; CCTK_REAL ye_atmo; CCTK_REAL press_atmo; - CCTK_REAL kappa_atmo; + CCTK_REAL entropy_atmo; CCTK_REAL rho_cut; CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline atmosphere() = default; CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline atmosphere( - CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL Ye_, CCTK_REAL press_, CCTK_REAL kappa_, + CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL Ye_, CCTK_REAL press_, CCTK_REAL entropy_, CCTK_REAL rho_cut_) - : rho_atmo(rho_), eps_atmo(eps_), ye_atmo(Ye_), press_atmo(press_), kappa_atmo(kappa_), + : rho_atmo(rho_), eps_atmo(eps_), ye_atmo(Ye_), press_atmo(press_), entropy_atmo(entropy_), rho_cut(rho_cut_) {} CCTK_DEVICE CCTK_HOST CCTK_ATTRIBUTE_ALWAYS_INLINE inline atmosphere & @@ -39,7 +39,7 @@ struct atmosphere { eps_atmo = other.eps_atmo; ye_atmo = other.ye_atmo; press_atmo = other.press_atmo; - kappa_atmo = other.kappa_atmo; + entropy_atmo = other.entropy_atmo; rho_cut = other.rho_cut; return *this; } @@ -51,7 +51,7 @@ struct atmosphere { pv.eps = eps_atmo; pv.Ye = ye_atmo; pv.press = press_atmo; - pv.kappa = kappa_atmo; + pv.entropy = entropy_atmo; pv.vel(0) = 0.0; pv.vel(1) = 0.0; pv.vel(2) = 0.0; @@ -71,7 +71,7 @@ struct atmosphere { cv.mom(1) = 0.0; cv.mom(2) = 0.0; cv.dYe = cv.dens * ye_atmo; - cv.dS = cv.dens * kappa_atmo; + cv.dS = cv.dens * entropy_atmo; const vec &B_up = pv.Bvec; const vec B_low = calc_contraction(g, B_up); CCTK_REAL Bsq = calc_contraction(B_up, B_low); diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index 898b6dab..e98bef60 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -94,7 +94,7 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ // add mass, keeps conserved density D pv.rho = cv.dens / w_lim; pv.eps = eos_th.eps_from_valid_rho_press_ye(pv.rho, pv.press, pv.Ye); - pv.kappa = + pv.entropy = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); // if (pv.rho >= rho_strict) { // rep.set_speed_limit({ sol_v, sol_v, sol_v }); @@ -115,7 +115,7 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ // remove mass, changes conserved density D pv.rho = rho_strict; pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); - pv.kappa = + pv.entropy = eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); rep.adjust_cons = true; @@ -138,7 +138,7 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ //} pv.eps = rgeps.max; pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.entropy = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); rep.adjust_cons = true; } else if (pv.eps < rgeps.min) { @@ -152,7 +152,7 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ // rep.set_range_eps(rgeps.min); // sets adjust_cons to true pv.eps = rgeps.min; pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.entropy = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); rep.adjust_cons = true; } diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 0aef02d5..c4548635 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -132,7 +132,7 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, const smat &glo) const { // Density, entropy, Ye pv.rho = xEntropy_Sol; - pv.kappa = cv.dS / cv.dens; + pv.entropy = cv.dS / cv.dens; pv.Ye = cv.dYe / cv.dens; // Lorentz factor @@ -140,8 +140,8 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, // Pressure and epsilon pv.press = - eos_th.press_from_valid_rho_kappa_ye(xEntropy_Sol, pv.kappa, pv.Ye); - pv.eps = eos_th.eps_from_valid_rho_kappa_ye(xEntropy_Sol, pv.kappa, pv.Ye); + eos_th.press_from_valid_rho_kappa_ye(xEntropy_Sol, pv.entropy, pv.Ye); + pv.eps = eos_th.eps_from_valid_rho_kappa_ye(xEntropy_Sol, pv.entropy, pv.Ye); // Taken from WZ2Prim (2DNRNoble) // Z_Sol = rho * h * w_lor * w_lor diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 91673ef8..582b61f2 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -221,7 +221,7 @@ c2p_1DPalenzuela::xPalenzuelaToPrim(CCTK_REAL xPalenzuela_Sol, CCTK_REAL Ssq, pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.entropy = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); pv.Bvec = cv.dBvec; diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index a345e7b1..cc96d6f5 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -244,7 +244,7 @@ c2p_2DNoble::WZ2Prim(CCTK_REAL Z_Sol, CCTK_REAL vsq_Sol, CCTK_REAL Bsq, pv.press = eos_th.press_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); - pv.kappa = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); + pv.entropy = eos_th.kappa_from_valid_rho_eps_ye(pv.rho, pv.eps, pv.Ye); pv.Bvec = cv.dBvec; diff --git a/Con2PrimFactory/src/cons.hxx b/Con2PrimFactory/src/cons.hxx index 9a9b43d1..ef103dee 100644 --- a/Con2PrimFactory/src/cons.hxx +++ b/Con2PrimFactory/src/cons.hxx @@ -85,7 +85,7 @@ struct cons_vars { dBvec = sqrt_detg * pv.Bvec; dYe = dens * pv.Ye; - dS = dens * pv.kappa; + dS = dens * pv.entropy; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void diff --git a/Con2PrimFactory/src/prims.hxx b/Con2PrimFactory/src/prims.hxx index 843c912b..baaebbb3 100644 --- a/Con2PrimFactory/src/prims.hxx +++ b/Con2PrimFactory/src/prims.hxx @@ -16,7 +16,16 @@ struct prim_vars { CCTK_REAL eps; CCTK_REAL Ye; CCTK_REAL press; - CCTK_REAL kappa; + CCTK_REAL entropy; +// entropy refers to the "evolved" entropy. +// However, note that this quantity is +// not necessarily the "physical" entropy. This depends on the EOS, e.g. +// for the ideal gas we have entropy = p rho^(-gamma). +// The distinction between "evolved" and "physical" entropy is made +// explicit in EOSX where functions with "entropy_..." and "kappa_..." +// refer to "physical" and "evolved" entropy, respectively. In this +// application thorn we always refer to entropy to describe +// the "evolved" entropy. vec vel; CCTK_REAL w_lor; vec Bvec; @@ -27,9 +36,9 @@ struct prim_vars { /// Construct from single variables. CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline prim_vars( - CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL ye_, CCTK_REAL press_, CCTK_REAL kappa_, + CCTK_REAL rho_, CCTK_REAL eps_, CCTK_REAL ye_, CCTK_REAL press_, CCTK_REAL entropy_, vec vel_, CCTK_REAL w_lor_, vec Bvec_) - : rho(rho_), eps(eps_), Ye(ye_), press(press_), kappa(kappa_), vel(vel_), w_lor(w_lor_), + : rho(rho_), eps(eps_), Ye(ye_), press(press_), entropy(entropy_), vel(vel_), w_lor(w_lor_), Bvec(Bvec_){}; /// Copy assignment @@ -42,7 +51,7 @@ struct prim_vars { eps = other.eps; Ye = other.Ye; press = other.press; - kappa = other.kappa; + entropy = other.entropy; vel = other.vel; w_lor = other.w_lor; Bvec = other.Bvec; @@ -51,7 +60,7 @@ struct prim_vars { } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void - scatter(CCTK_REAL &rho_, CCTK_REAL &eps_, CCTK_REAL &ye_, CCTK_REAL &press_, CCTK_REAL &kappa_, + scatter(CCTK_REAL &rho_, CCTK_REAL &eps_, CCTK_REAL &ye_, CCTK_REAL &press_, CCTK_REAL &entropy_, CCTK_REAL &velx_, CCTK_REAL &vely_, CCTK_REAL &velz_, CCTK_REAL &w_lor_, CCTK_REAL &Bvec_x_, CCTK_REAL &Bvec_y_, CCTK_REAL &Bvec_z_, CCTK_REAL &E_x_, CCTK_REAL &E_y_, @@ -60,7 +69,7 @@ struct prim_vars { eps_ = eps; ye_ = Ye; press_ = press; - kappa_ = kappa; + entropy_ = entropy; velx_ = vel(0); vely_ = vel(1); velz_ = vel(2); @@ -74,7 +83,7 @@ struct prim_vars { } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan() { - rho = eps = Ye = press = kappa = vel(0) = vel(1) = vel(2) = w_lor = Bvec(0) = + rho = eps = Ye = press = entropy = vel(0) = vel(1) = vel(2) = w_lor = Bvec(0) = Bvec(1) = Bvec(2) = E(0) = E(1) = E(2) = std::numeric_limits::quiet_NaN(); } diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index 46f9b383..36d14c5e 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -103,7 +103,7 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "By: %f, %f \n" "Bz: %f, %f \n", pv_seeds.rho, pv.rho, pv_seeds.eps, pv.eps, pv_seeds.Ye, pv.Ye, - pv_seeds.press, pv.press, pv_seeds.kappa, pv.kappa, + pv_seeds.press, pv.press, pv_seeds.entropy, pv.entropy, pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), pv.vel(1), pv_seeds.vel(2), pv.vel(2), pv_seeds.Bvec(0), pv.Bvec(0), pv_seeds.Bvec(1), pv.Bvec(1), pv_seeds.Bvec(2), pv.Bvec(2)); @@ -148,7 +148,7 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "By: %f, %f \n" "Bz: %f, %f \n", pv_seeds.rho, pv.rho, pv_seeds.eps, pv.eps, pv_seeds.Ye, pv.Ye, - pv_seeds.press, pv.press, pv_seeds.kappa, pv.kappa, + pv_seeds.press, pv.press, pv_seeds.entropy, pv.entropy, pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), pv.vel(1), pv_seeds.vel(2), pv.vel(2), pv_seeds.Bvec(0), pv.Bvec(0), pv_seeds.Bvec(1), pv.Bvec(1), pv_seeds.Bvec(2), pv.Bvec(2)); @@ -191,7 +191,7 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "By: %f, %f \n" "Bz: %f, %f \n", pv_seeds.rho, pv.rho, pv_seeds.eps, pv.eps, pv_seeds.Ye, pv.Ye, - pv_seeds.press, pv.press, pv_seeds.kappa, pv.kappa, + pv_seeds.press, pv.press, pv_seeds.entropy, pv.entropy, pv_seeds.vel(0), pv.vel(0), pv_seeds.vel(1), pv.vel(1), pv_seeds.vel(2), pv.vel(2), pv_seeds.Bvec(0), pv.Bvec(0), pv_seeds.Bvec(1), pv.Bvec(1), pv_seeds.Bvec(2), pv.Bvec(2)); diff --git a/EOSX/src/eos_idealgas.hxx b/EOSX/src/eos_idealgas.hxx index e913c66b..7807cb97 100644 --- a/EOSX/src/eos_idealgas.hxx +++ b/EOSX/src/eos_idealgas.hxx @@ -98,6 +98,13 @@ public: const CCTK_REAL ye ) const; + // Note that kappa implements a generic thermodynamic quantity + // meant to describe the "evolved" entropy by an evolution/application + // thorn. + // The notion of the "evolved" entropy (kappa) might differ from the definition + // of the actual entropy (entropy_from..., see above) for different EOS, + // e.g. for the ideal gas EOS we have kappa = p * (rho)^(-gamma), + // where gamma is the adiabatic index. CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL kappa_from_valid_rho_eps_ye( const CCTK_REAL rho, @@ -212,6 +219,13 @@ eos_idealgas::eps_from_valid_rho_kappa_ye( return kappa*pow(rho,gamma-1.0)/(gamma-1.0); }; +// Note that kappa implements a generic thermodynamic quantity +// meant to describe the "evolved" entropy by an evolution/application +// thorn. +// The notion of the "evolved" entropy (kappa) might differ from the definition +// of the actual entropy (entropy_from..., see above) for different EOS, +// e.g. for the ideal gas EOS we have kappa = p * (rho)^(-gamma), +// where gamma is the adiabatic index. CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL eos_idealgas::kappa_from_valid_rho_eps_ye( const CCTK_REAL rho, From 361068965186e91c777b366cd7864dcb6dbec893 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 25 Nov 2024 10:57:41 -0600 Subject: [PATCH 42/50] AsterX: Debug comments related to v>1 --- AsterX/src/con2prim.cxx | 2 ++ Con2PrimFactory/src/c2p_1DEntropy.hxx | 2 ++ Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 2 ++ Con2PrimFactory/src/c2p_2DNoble.hxx | 8 ++++++++ 4 files changed, 14 insertions(+) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 7b8113d6..000bbaf8 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -115,6 +115,8 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, vec v_low = calc_contraction(glo, v_up); CCTK_REAL zsq{0.0}; + // TODO: Debug code to capture v>1 early, + // remove soon const CCTK_REAL vsq = calc_contraction(v_low,v_up); if (vsq >= 1.0) { CCTK_REAL wlim = sqrt(1.0 + vw_lim * vw_lim); diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index c4548635..be8781ef 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -148,6 +148,8 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, CCTK_REAL Z_Sol = (xEntropy_Sol + pv.eps * xEntropy_Sol + pv.press) * pv.w_lor * pv.w_lor; + // TODO: Debug code to capture v>1, + // remove soon if (use_zprim) { CCTK_REAL zx = diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 582b61f2..12cc8527 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -165,6 +165,8 @@ c2p_1DPalenzuela::xPalenzuelaToPrim(CCTK_REAL xPalenzuela_Sol, CCTK_REAL Ssq, // Taken from WZ2Prim (2DNRNoble) CCTK_REAL Z_Sol = xPalenzuela_Sol * pv.rho * W_sol; + // TODO: Debug code to capture v>1, + // remove soon if (use_zprim) { CCTK_REAL zx = diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index cc96d6f5..cacbfead 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -33,6 +33,8 @@ public: get_WLorentz_vsq_bsq_Seeds(const vec &B_up, const vec &v_up, const smat &glo) const; + // TODO: Debug function to capture v>1, + // remove soon CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec getZ_WLorentz_vsq_bsq_Seeds(const vec &B_up, const vec &z_up, @@ -128,6 +130,8 @@ c2p_2DNoble::get_WLorentz_vsq_bsq_Seeds(const vec &B_up, return w_vsq_bsq; //{w_lor, vsq, bsq} } +// TODO: Debug function to capture v>1, +// remove soon CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline vec c2p_2DNoble::getZ_WLorentz_vsq_bsq_Seeds(const vec &B_up, const vec &z_up, @@ -185,6 +189,8 @@ c2p_2DNoble::WZ2Prim(CCTK_REAL Z_Sol, CCTK_REAL vsq_Sol, CCTK_REAL Bsq, pv.rho = cv.dens / W_Sol; + // TODO: Debug code to capture v>1, + // remove soon if (use_zprim) { CCTK_REAL zx = @@ -314,6 +320,8 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, vec w_vsq_bsq; CCTK_REAL vsq_seed; + // TODO: Debug code to capture v>1, + // remove soon if (use_zprim) { vec zvec = pv_seeds.vel*pv_seeds.w_lor; From 6995bdb3ddba7cc504aeeb2d848bc02a6443ba83 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 25 Nov 2024 15:02:35 -0600 Subject: [PATCH 43/50] AsterX: Rewrite C2P failure code --- AsterX/src/con2prim.cxx | 164 +++++++++++++++--------------------- Con2PrimFactory/src/c2p.hxx | 35 ++++++++ 2 files changed, 104 insertions(+), 95 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index 000bbaf8..ed19d12a 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -139,6 +139,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, prim_vars pv; prim_vars pv_seeds{saved_rho(p.I), saved_eps(p.I), dummy_Ye, press(p.I), entropy(p.I), v_up, wlor, Bup}; + // Note that pv_seeds.press and pv_seeds.entropy are NaN at this point // Note that cv are densitized, i.e. they all include sqrt_detg cons_vars cv{dens(p.I), {momx(p.I), momy(p.I), momz(p.I)}, @@ -163,24 +164,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, if (alp(p.I) < alp_thresh) { if ((pv_seeds.rho > rho_BH) || (pv_seeds.eps > eps_BH)) { - pv_seeds.rho = rho_BH; // typically set to 0.01% to 1% of rho_max of - // initial NS or disk - pv_seeds.eps = eps_BH; - pv_seeds.Ye = Ye_atmo; - pv_seeds.press = - eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); - pv_seeds.entropy = - eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); - // check on velocities - CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); - CCTK_REAL vlim_BH = vwlim_BH / wlim_BH; - CCTK_REAL sol_v = - sqrt((pv_seeds.w_lor * pv_seeds.w_lor - 1.0)) / pv_seeds.w_lor; - if (sol_v > vlim_BH) { - pv_seeds.vel *= vlim_BH / sol_v; - pv_seeds.w_lor = wlim_BH; - } - cv.from_prim(pv_seeds, glo); + c2p_Noble.bh_interior_fail(eos_th,pv,cv,glo); } } @@ -237,101 +221,91 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, if (rep_ent.failed()) { + con2prim_flag(p.I) = 0; + if (debug_mode) { printf("Entropy C2P failed. Setting point to atmosphere.\n"); rep_ent.debug_message(); + printf( + "WARNING: \n" + "C2Ps failed. Printing cons and saved prims before set to " + "atmo: \n" + "cctk_iteration = %i \n " + "x, y, z = %26.16e, %26.16e, %26.16e \n " + "dens = %26.16e \n tau = %26.16e \n momx = %26.16e \n " + "momy = %26.16e \n momz = %26.16e \n dBx = %26.16e \n " + "dBy = %26.16e \n dBz = %26.16e \n " + "saved_rho = %26.16e \n saved_eps = %26.16e \n press= %26.16e \n " + "saved_velx = %26.16e \n saved_vely = %26.16e \n saved_velz = " + "%26.16e \n " + "Bvecx = %26.16e \n Bvecy = %26.16e \n " + "Bvecz = %26.16e \n " + "Avec_x = %26.16e \n Avec_y = %26.16e \n Avec_z = %26.16e \n ", + cctk_iteration, p.x, p.y, p.z, dens(p.I), tau(p.I), momx(p.I), + momy(p.I), momz(p.I), dBx(p.I), dBy(p.I), dBz(p.I), pv.rho, pv.eps, + pv.press, pv.vel(0), pv.vel(1), pv.vel(2), pv.Bvec(0), pv.Bvec(1), + pv.Bvec(2), + // rho(p.I), eps(p.I), press(p.I), velx(p.I), vely(p.I), + // velz(p.I), Bvecx(p.I), Bvecy(p.I), Bvecz(p.I), + Avec_x(p.I), Avec_y(p.I), Avec_z(p.I)); } - // set to atmo - cv.dBvec(0) = dBx(p.I); - cv.dBvec(1) = dBy(p.I); - cv.dBvec(2) = dBz(p.I); - pv.Bvec = cv.dBvec / sqrt_detg; - atmo.set(pv, cv, glo); - - con2prim_flag(p.I) = 0; + if ( (alp(p.I) < alp_thresh) && ( (pv_seeds.rho > rho_BH) || (pv_seeds.eps > eps_BH) ) ) { + c2p_Noble.bh_interior_fail(eos_th,pv,cv,glo); + } else { + // set to atmo + cv.dBvec(0) = dBx(p.I); + cv.dBvec(1) = dBy(p.I); + cv.dBvec(2) = dBz(p.I); + pv.Bvec = cv.dBvec / sqrt_detg; + atmo.set(pv, cv, glo); + } } } else { + con2prim_flag(p.I) = 0; + if (debug_mode) { printf("Second C2P failed too :( :( \n"); rep_second.debug_message(); + printf( + "WARNING: \n" + "C2Ps failed. Printing cons and saved prims before set to " + "atmo: \n" + "cctk_iteration = %i \n " + "x, y, z = %26.16e, %26.16e, %26.16e \n " + "dens = %26.16e \n tau = %26.16e \n momx = %26.16e \n " + "momy = %26.16e \n momz = %26.16e \n dBx = %26.16e \n " + "dBy = %26.16e \n dBz = %26.16e \n " + "saved_rho = %26.16e \n saved_eps = %26.16e \n press= %26.16e \n " + "saved_velx = %26.16e \n saved_vely = %26.16e \n saved_velz = " + "%26.16e \n " + "Bvecx = %26.16e \n Bvecy = %26.16e \n " + "Bvecz = %26.16e \n " + "Avec_x = %26.16e \n Avec_y = %26.16e \n Avec_z = %26.16e \n ", + cctk_iteration, p.x, p.y, p.z, dens(p.I), tau(p.I), momx(p.I), + momy(p.I), momz(p.I), dBx(p.I), dBy(p.I), dBz(p.I), pv.rho, pv.eps, + pv.press, pv.vel(0), pv.vel(1), pv.vel(2), pv.Bvec(0), pv.Bvec(1), + pv.Bvec(2), + // rho(p.I), eps(p.I), press(p.I), velx(p.I), vely(p.I), + // velz(p.I), Bvecx(p.I), Bvecy(p.I), Bvecz(p.I), + Avec_x(p.I), Avec_y(p.I), Avec_z(p.I)); } - rep_first.set_atmo = true; - rep_second.set_atmo = true; - - con2prim_flag(p.I) = 0; - - // Treatment for BH interiors after C2P failures - // NOTE: By default, alp_thresh=0 so the if condition below is never - // triggered. One must be very careful when using this functionality and - // must correctly set alp_thresh, rho_BH, eps_BH and vwlim_BH in the - // parfile - if (alp(p.I) < alp_thresh) { - if ((pv_seeds.rho > rho_BH) || (pv_seeds.eps > eps_BH)) { - pv.rho = rho_BH; // typically set to 0.01% to 1% of rho_max of initial - // NS or disk - pv.eps = eps_BH; - pv.Ye = Ye_atmo; - pv.press = - eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); - pv.entropy = - eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); - // check on velocities - CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); - CCTK_REAL vlim_BH = vwlim_BH / wlim_BH; - CCTK_REAL sol_v = sqrt((pv.w_lor * pv.w_lor - 1.0)) / pv.w_lor; - if (sol_v > vlim_BH) { - pv.vel *= vlim_BH / sol_v; - pv.w_lor = wlim_BH; - } - cv.from_prim(pv, glo); - rep_first.set_atmo = 0; - rep_second.set_atmo = 0; - rep_ent.set_atmo = 0; - } + if ( (alp(p.I) < alp_thresh) && ( (pv_seeds.rho > rho_BH) || (pv_seeds.eps > eps_BH) ) ) { + c2p_Noble.bh_interior_fail(eos_th,pv,cv,glo); + } else { + // set to atmo + cv.dBvec(0) = dBx(p.I); + cv.dBvec(1) = dBy(p.I); + cv.dBvec(2) = dBz(p.I); + pv.Bvec = cv.dBvec / sqrt_detg; + atmo.set(pv, cv, glo); } } } - if (rep_first.set_atmo && rep_second.set_atmo && !(use_entropy_fix)) { - if (debug_mode) { - printf( - "WARNING: \n" - "C2Ps failed. Printing cons and saved prims before set to " - "atmo: \n" - "cctk_iteration = %i \n " - "x, y, z = %26.16e, %26.16e, %26.16e \n " - "dens = %26.16e \n tau = %26.16e \n momx = %26.16e \n " - "momy = %26.16e \n momz = %26.16e \n dBx = %26.16e \n " - "dBy = %26.16e \n dBz = %26.16e \n " - "saved_rho = %26.16e \n saved_eps = %26.16e \n press= %26.16e \n " - "saved_velx = %26.16e \n saved_vely = %26.16e \n saved_velz = " - "%26.16e \n " - "Bvecx = %26.16e \n Bvecy = %26.16e \n " - "Bvecz = %26.16e \n " - "Avec_x = %26.16e \n Avec_y = %26.16e \n Avec_z = %26.16e \n ", - cctk_iteration, p.x, p.y, p.z, dens(p.I), tau(p.I), momx(p.I), - momy(p.I), momz(p.I), dBx(p.I), dBy(p.I), dBz(p.I), pv.rho, pv.eps, - pv.press, pv.vel(0), pv.vel(1), pv.vel(2), pv.Bvec(0), pv.Bvec(1), - pv.Bvec(2), - // rho(p.I), eps(p.I), press(p.I), velx(p.I), vely(p.I), - // velz(p.I), Bvecx(p.I), Bvecy(p.I), Bvecz(p.I), - Avec_x(p.I), Avec_y(p.I), Avec_z(p.I)); - } - - // set to atmo - cv.dBvec(0) = dBx(p.I); - cv.dBvec(1) = dBy(p.I); - cv.dBvec(2) = dBz(p.I); - pv.Bvec = cv.dBvec / sqrt_detg; - atmo.set(pv, cv, glo); - - // assert(0); - } - // dummy vars CCTK_REAL Ex, Ey, Ez; diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index e98bef60..51c5f662 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -65,6 +65,11 @@ protected: CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_vars &cv, const smat &glo, c2p_report &rep) const; + + template + CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void + bh_interior_fail(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, + const smat &glo) const; }; template @@ -161,6 +166,36 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ } +template +CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void +c2p::bh_interior_fail(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, + const smat &glo) const { + + // Treatment for BH interiors after C2P failures + // NOTE: By default, alp_thresh=0 so the if condition below is never + // triggered. One must be very careful when using this functionality and + // must correctly set alp_thresh, rho_BH, eps_BH and vwlim_BH in the + // parfile + pv.rho = rho_BH; // typically set to 0.01% to 1% of rho_max of initial + // NS or disk + pv.eps = eps_BH; + pv.Ye = Ye_atmo; + pv.press = + eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); + pv.entropy = + eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); + // check on velocities + CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); + CCTK_REAL vlim_BH = vwlim_BH / wlim_BH; + CCTK_REAL sol_v = sqrt((pv.w_lor * pv.w_lor - 1.0)) / pv.w_lor; + if (sol_v > vlim_BH) { + pv.vel *= vlim_BH / sol_v; + pv.w_lor = wlim_BH; + } + cv.from_prim(pv, glo); + +} + } // namespace Con2PrimFactory #endif From cb3c9dfb542ee56eb95b245897bbe9990c2010d3 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 25 Nov 2024 15:05:25 -0600 Subject: [PATCH 44/50] Con2PrimFactory: Change meaning of rho_strict temporarily --- Con2PrimFactory/param.ccl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Con2PrimFactory/param.ccl b/Con2PrimFactory/param.ccl index da66acad..0b3d90c9 100644 --- a/Con2PrimFactory/param.ccl +++ b/Con2PrimFactory/param.ccl @@ -52,7 +52,8 @@ CCTK_REAL vw_lim "Upper limit for the value of velocity * lorentz_factor " STEER 0: :: "Must be positive" } 10.0 -CCTK_REAL rho_strict "Density above which RePrimAnd c2p corrections are forbidden" STEERABLE=ALWAYS +# TODO: Change name +CCTK_REAL rho_strict "Density ceiling after C2P" STEERABLE=ALWAYS { 0: :: "Must be positive" } 1e100 From b6358f41ca1b1d11fe29a183dd42513ab0fa1d3b Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 25 Nov 2024 16:12:44 -0600 Subject: [PATCH 45/50] AsterX: Consistent variable naming --- AsterX/interface.ccl | 14 +++++------ AsterX/schedule.ccl | 30 ++++++++++++------------ AsterX/src/con2prim.cxx | 4 ++-- AsterX/src/con2prim_rpa.cxx | 2 +- AsterX/src/fluxes.cxx | 15 ++++++------ AsterX/src/prim2con.cxx | 2 +- AsterX/src/rhs.cxx | 4 ++-- AsterX/src/source.cxx | 2 +- Con2PrimFactory/src/atmo.hxx | 2 +- Con2PrimFactory/src/c2p_1DEntropy.hxx | 14 +++++------ Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 8 +++---- Con2PrimFactory/src/c2p_2DNoble.hxx | 6 ++--- Con2PrimFactory/src/cons.hxx | 16 ++++++------- Con2PrimFactory/src/test.cxx | 12 +++++----- 14 files changed, 66 insertions(+), 65 deletions(-) diff --git a/AsterX/interface.ccl b/AsterX/interface.ccl index 6f1d2c37..c6b6c40a 100644 --- a/AsterX/interface.ccl +++ b/AsterX/interface.ccl @@ -23,7 +23,7 @@ CCTK_REAL mom TYPE=gf CENTERING={ccc} TAGS='rhs="momrhs" dependents="HydroBaseX: CCTK_REAL tau TYPE=gf CENTERING={ccc} TAGS='rhs="taurhs" dependents="HydroBaseX::eps HydroBaseX::press HydroBaseX::temperature HydroBaseX::Ye HydroBaseX::Bvec TmunuBaseX::eTij"' "Conserved internal energy density" -# sstar is the conserved "evolved" entropy. +# DEnt is the conserved "evolved" entropy. # The corresponding primitive is stored in HydroBaseX::entropy. # However, note that this gf stores the "evolved" entropy which is # not necessarily the "physical" entropy. This depends on the EOS, e.g. @@ -31,16 +31,16 @@ CCTK_REAL tau TYPE=gf CENTERING={ccc} TAGS='rhs="taurhs" dependents="HydroBaseX: # The distinction between "evolved" and "physical" entropy is made # explicit in EOSX where functions with "entropy_..." and "kappa_..." # refer to "physical" and "evolved" entropy, respectively. In this -# evolution thorn we always refer to sstar and entropy to describe +# evolution thorn we always refer to DEnt and entropy to describe # the "evolved" quantities. -CCTK_REAL sstar TYPE=gf CENTERING={ccc} TAGS='rhs="sstarrhs" dependents="HydroBaseX::entropy AsterX::flux_x AsterX::flux_y AsterX::flux_z"' "Advected entropy density" +CCTK_REAL DEnt TYPE=gf CENTERING={ccc} TAGS='rhs="DEntrhs" dependents="HydroBaseX::entropy AsterX::flux_x AsterX::flux_y AsterX::flux_z"' "Advected entropy density" CCTK_REAL flux_x TYPE=gf CENTERING={vcc} TAGS='checkpoint="no"' { fxdens fxmomx fxmomy fxmomz fxtau - fxsstar + fxDEnt fxBx fxBy fxBz } "Fluxes in x direction" @@ -49,7 +49,7 @@ CCTK_REAL flux_y TYPE=gf CENTERING={cvc} TAGS='checkpoint="no"' fydens fymomx fymomy fymomz fytau - fysstar + fyDEnt fyBx fyBy fyBz } "Fluxes in y direction" @@ -58,7 +58,7 @@ CCTK_REAL flux_z TYPE=gf CENTERING={ccv} TAGS='checkpoint="no"' fzdens fzmomx fzmomy fzmomz fztau - fzsstar + fzDEnt fzBx fzBy fzBz } "Fluxes in z direction" @@ -71,7 +71,7 @@ CCTK_REAL momrhs TYPE=gf CENTERING={ccc} TAGS='checkpoint="no"' CCTK_REAL taurhs TYPE=gf CENTERING={ccc} TAGS='checkpoint="no"' "Conserved internal energy density RHS" -CCTK_REAL sstarrhs TYPE=gf CENTERING={ccc} TAGS='checkpoint="no"' "Advected entropy density RHS" +CCTK_REAL DEntrhs TYPE=gf CENTERING={ccc} TAGS='checkpoint="no"' "Advected entropy density RHS" CCTK_REAL Avec_x TYPE=gf CENTERING={cvv} TAGS='rhs="Avec_x_rhs"' "x-component of vector potential" CCTK_REAL Avec_y TYPE=gf CENTERING={vcv} TAGS='rhs="Avec_y_rhs"' "y-component of vector potential" diff --git a/AsterX/schedule.ccl b/AsterX/schedule.ccl index 73c76699..8b67a204 100644 --- a/AsterX/schedule.ccl +++ b/AsterX/schedule.ccl @@ -1,8 +1,8 @@ # Schedule definitions for thorn AsterX -STORAGE: dens mom tau sstar dB Psi HydroBaseX::Bvec dBx_stag dBy_stag dBz_stag +STORAGE: dens mom tau DEnt dB Psi HydroBaseX::Bvec dBx_stag dBy_stag dBz_stag STORAGE: flux_x flux_y flux_z -STORAGE: densrhs momrhs taurhs sstarrhs Avec_x_rhs Avec_y_rhs Avec_z_rhs Psi_rhs +STORAGE: densrhs momrhs taurhs DEntrhs Avec_x_rhs Avec_y_rhs Avec_z_rhs Psi_rhs STORAGE: ADMBaseX::metric ADMBaseX::lapse ADMBaseX::shift ADMBaseX::curv STORAGE: Aux_in_RHSof_A_Psi STORAGE: TmunuBaseX::eTtt TmunuBaseX::eTti TmunuBaseX::eTij @@ -70,12 +70,12 @@ SCHEDULE AsterX_Prim2Con_Initial IN AsterX_InitialGroup AFTER AsterX_ComputeBFro READS: ADMBaseX::metric(interior) READS: HydroBaseX::rho(interior) HydroBaseX::vel(interior) HydroBaseX::eps(interior) HydroBaseX::press(interior) HydroBaseX::Bvec(interior) READS: HydroBaseX::entropy(interior) - WRITES: dens(interior) tau(interior) sstar(interior) mom(interior) dB(interior) + WRITES: dens(interior) tau(interior) DEnt(interior) mom(interior) dB(interior) WRITES: Psi(everywhere) WRITES: saved_prims WRITES: zvec WRITES: svec - SYNC: dens tau sstar mom dB + SYNC: dens tau DEnt mom dB SYNC: saved_prims SYNC: zvec SYNC: svec @@ -87,7 +87,7 @@ SCHEDULE AsterX_Sync AT postregrid { LANG: C OPTIONS: global - SYNC: dens tau mom sstar Avec_x Avec_y Avec_z Psi + SYNC: dens tau mom DEnt Avec_x Avec_y Avec_z Psi SYNC: saved_prims } "Synchronize" @@ -95,7 +95,7 @@ SCHEDULE AsterX_Sync IN ODESolvers_PostStep { LANG: C OPTIONS: global - SYNC: dens tau mom sstar Avec_x Avec_y Avec_z Psi + SYNC: dens tau mom DEnt Avec_x Avec_y Avec_z Psi } "Synchronize" @@ -125,7 +125,7 @@ SCHEDULE AsterX_Con2Prim IN AsterX_Con2PrimGroup AFTER AsterX_ComputedBFromdBsta LANG: C READS: ADMBaseX::metric(interior) READS: ADMBaseX::lapse(everywhere) - READS: dens(interior) tau(interior) sstar(interior) mom(interior) dB(interior) + READS: dens(interior) tau(interior) DEnt(interior) mom(interior) dB(interior) READS: saved_prims(interior) READS: Avec_x(interior) Avec_y(interior) Avec_z(interior) WRITES: con2prim_flag(interior) @@ -134,14 +134,14 @@ SCHEDULE AsterX_Con2Prim IN AsterX_Con2PrimGroup AFTER AsterX_ComputedBFromdBsta WRITES: saved_prims(interior) WRITES: zvec(interior) WRITES: svec(interior) - WRITES: dens(interior) tau(interior) sstar(interior) mom(interior) dB(interior) + WRITES: dens(interior) tau(interior) DEnt(interior) mom(interior) dB(interior) SYNC: con2prim_flag SYNC: HydroBaseX::rho HydroBaseX::vel HydroBaseX::eps HydroBaseX::press HydroBaseX::Bvec SYNC: HydroBaseX::entropy SYNC: saved_prims SYNC: zvec SYNC: svec - SYNC: dens tau sstar mom dB + SYNC: dens tau DEnt mom dB } "Calculate primitive variables from conservative variables" @@ -156,7 +156,7 @@ SCHEDULE AsterX_Fluxes IN AsterX_RHSGroup READS: ADMBaseX::metric(everywhere) READS: ADMBaseX::lapse(everywhere) READS: ADMBaseX::shift(everywhere) - READS: dens(everywhere) tau(everywhere) mom(everywhere) sstar(everywhere) + READS: dens(everywhere) tau(everywhere) mom(everywhere) DEnt(everywhere) READS: HydroBaseX::rho(everywhere) HydroBaseX::vel(everywhere) HydroBaseX::press(everywhere) HydroBaseX::eps(everywhere) READS: HydroBaseX::Bvec(everywhere) READS: HydroBaseX::entropy(everywhere) @@ -185,8 +185,8 @@ SCHEDULE AsterX_SourceTerms IN AsterX_RHSGroup AFTER AsterX_Fluxes READS: zvec_x(everywhere), zvec_y(everywhere), zvec_z(everywhere) READS: svec_x(everywhere), svec_y(everywhere), svec_z(everywhere) READS: HydroBaseX::Bvec(everywhere) - WRITES: densrhs(interior) taurhs(interior) momrhs(interior) sstarrhs(interior) - SYNC: densrhs taurhs momrhs sstarrhs + WRITES: densrhs(interior) taurhs(interior) momrhs(interior) DEntrhs(interior) + SYNC: densrhs taurhs momrhs DEntrhs } "Calculate the source terms and compute the RHS of the hydro equations" SCHEDULE AsterX_RHS IN AsterX_RHSGroup AFTER AsterX_SourceTerms @@ -195,15 +195,15 @@ SCHEDULE AsterX_RHS IN AsterX_RHSGroup AFTER AsterX_SourceTerms READS: ADMBaseX::metric(everywhere) ADMBaseX::lapse(everywhere) ADMBaseX::shift(everywhere) READS: HydroBaseX::vel(everywhere) HydroBaseX::press(everywhere) READS: flux_x(everywhere) flux_y(everywhere) flux_z(everywhere) - READS: densrhs(everywhere) taurhs(everywhere) momrhs(everywhere) sstarrhs(everywhere) + READS: densrhs(everywhere) taurhs(everywhere) momrhs(everywhere) DEntrhs(everywhere) READS: Psi(everywhere) READS: Aux_in_RHSof_A_Psi(everywhere) READS: dBx_stag(everywhere) dBy_stag(everywhere) dBz_stag(everywhere) READS: vtilde_xface(everywhere) vtilde_yface(everywhere) vtilde_zface(everywhere) READS: a_xface(everywhere) a_yface(everywhere) a_zface(everywhere) - WRITES: densrhs(interior) taurhs(interior) momrhs(interior) sstarrhs(interior) + WRITES: densrhs(interior) taurhs(interior) momrhs(interior) DEntrhs(interior) WRITES: Avec_x_rhs(interior) Avec_y_rhs(interior) Avec_z_rhs(interior) Psi_rhs(interior) - SYNC: densrhs taurhs momrhs sstarrhs + SYNC: densrhs taurhs momrhs DEntrhs SYNC: Avec_x_rhs Avec_y_rhs Avec_z_rhs Psi_rhs } "Update the RHS of the hydro equations with the flux contributions" diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index ed19d12a..ad773634 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -145,7 +145,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, {momx(p.I), momy(p.I), momz(p.I)}, tau(p.I), dummy_dYe, - sstar(p.I), + DEnt(p.I), {dBx(p.I), dBy(p.I), dBz(p.I)}}; if (dens(p.I) <= sqrt_detg * rho_atmo_cut) { @@ -326,7 +326,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, // Write back cv cv.scatter(dens(p.I), momx(p.I), momy(p.I), momz(p.I), tau(p.I), dummy_Ye, - sstar(p.I), dBx(p.I), dBy(p.I), dBz(p.I)); + DEnt(p.I), dBx(p.I), dBy(p.I), dBz(p.I)); // Update saved prims saved_rho(p.I) = rho(p.I); diff --git a/AsterX/src/con2prim_rpa.cxx b/AsterX/src/con2prim_rpa.cxx index 17620d6a..30dbee8b 100644 --- a/AsterX/src/con2prim_rpa.cxx +++ b/AsterX/src/con2prim_rpa.cxx @@ -110,7 +110,7 @@ extern "C" void AsterX_Con2Prim(CCTK_ARGUMENTS) { {dBx(p.I), dBy(p.I), dBz(p.I)}}; // Invert entropy here - entropy(p.I) = sstar(p.I)/dens(p.I); + entropy(p.I) = DEnt(p.I)/dens(p.I); // Modifying primitive seeds within BH interiors before C2Ps are called // NOTE: By default, alp_thresh=0 so the if condition below is never diff --git a/AsterX/src/fluxes.cxx b/AsterX/src/fluxes.cxx index 75755752..7f14092c 100644 --- a/AsterX/src/fluxes.cxx +++ b/AsterX/src/fluxes.cxx @@ -44,7 +44,7 @@ void CalcFlux(CCTK_ARGUMENTS, EOSType &eos_th) { /* grid functions for fluxes */ const vec, dim> fluxdenss{fxdens, fydens, fzdens}; - const vec, dim> fluxsstars{fxsstar, fysstar, fzsstar}; + const vec, dim> fluxDEnts{fxDEnt, fyDEnt, fzDEnt}; const vec, dim> fluxmomxs{fxmomx, fymomx, fzmomx}; const vec, dim> fluxmomys{fxmomy, fymomy, fzmomy}; const vec, dim> fluxmomzs{fxmomz, fymomz, fzmomz}; @@ -390,8 +390,9 @@ void CalcFlux(CCTK_ARGUMENTS, EOSType &eos_th) { return sqrtg * rho_rc(f) * w_lorentz_rc(f); }); - /* sstar = sqrt(g) * D * s = sqrt(g) * (rho * W) * s */ - const vec sstar_rc([&](int f) ARITH_INLINE { + /* DEnt = sqrt(g) * D * s = sqrt(g) * (rho * W) * s */ + /* s = entropy */ + const vec DEnt_rc([&](int f) ARITH_INLINE { return sqrtg * rho_rc(f) * w_lorentz_rc(f) * entropy_rc(f); }); @@ -436,9 +437,9 @@ void CalcFlux(CCTK_ARGUMENTS, EOSType &eos_th) { const vec flux_dens( [&](int f) ARITH_INLINE { return dens_rc(f) * vtilde_rc(f); }); - /* flux(sstar) = sqrt(g) * D * s * vtilde^i = sqrt(g) * rho * W * s * vtilde^i */ - const vec flux_sstar( - [&](int f) ARITH_INLINE { return sstar_rc(f) * vtilde_rc(f); }); + /* flux(DEnt) = sqrt(g) * D * s * vtilde^i = sqrt(g) * rho * W * s * vtilde^i */ + const vec flux_DEnt( + [&](int f) ARITH_INLINE { return DEnt_rc(f) * vtilde_rc(f); }); /* flux(mom_j)^i = sqrt(g)*( * S_j*vtilde^i + alpha*((pgas+pmag)*delta^i_j - b_jB^i/W) ) */ @@ -476,7 +477,7 @@ void CalcFlux(CCTK_ARGUMENTS, EOSType &eos_th) { /* Calculate numerical fluxes */ fluxdenss(dir)(p.I) = calcflux(lambda, dens_rc, flux_dens); - fluxsstars(dir)(p.I) = calcflux(lambda, sstar_rc, flux_sstar); + fluxDEnts(dir)(p.I) = calcflux(lambda, DEnt_rc, flux_DEnt); fluxmomxs(dir)(p.I) = calcflux(lambda, moms_rc(0), flux_moms(0)); fluxmomys(dir)(p.I) = calcflux(lambda, moms_rc(1), flux_moms(1)); fluxmomzs(dir)(p.I) = calcflux(lambda, moms_rc(2), flux_moms(2)); diff --git a/AsterX/src/prim2con.cxx b/AsterX/src/prim2con.cxx index 4f0cb7f6..27092968 100644 --- a/AsterX/src/prim2con.cxx +++ b/AsterX/src/prim2con.cxx @@ -44,7 +44,7 @@ extern "C" void AsterX_Prim2Con_Initial(CCTK_ARGUMENTS) { dBy(p.I) = cv.dBvec(1); dBz(p.I) = cv.dBvec(2); - sstar(p.I) = entropy(p.I)*cv.dens; + DEnt(p.I) = entropy(p.I)*cv.dens; saved_rho(p.I) = pv.rho; saved_velx(p.I) = pv.vel(0); diff --git a/AsterX/src/rhs.cxx b/AsterX/src/rhs.cxx index 04e0a9bb..562b684d 100644 --- a/AsterX/src/rhs.cxx +++ b/AsterX/src/rhs.cxx @@ -71,7 +71,7 @@ extern "C" void AsterX_RHS(CCTK_ARGUMENTS) { 1 / CCTK_DELTA_SPACE(2)}; const vec, dim> gf_fdens{fxdens, fydens, fzdens}; - const vec, dim> gf_fsstar{fxsstar, fysstar, fzsstar}; + const vec, dim> gf_fDEnt{fxDEnt, fyDEnt, fzDEnt}; const vec, dim> gf_fmomx{fxmomx, fymomx, fzmomx}; const vec, dim> gf_fmomy{fxmomy, fymomy, fzmomy}; const vec, dim> gf_fmomz{fxmomz, fymomz, fzmomz}; @@ -188,7 +188,7 @@ extern "C" void AsterX_RHS(CCTK_ARGUMENTS) { grid.nghostzones, [=] CCTK_DEVICE(const PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE { densrhs(p.I) += calcupdate_hydro(gf_fdens, p); - sstarrhs(p.I) += calcupdate_hydro(gf_fsstar, p); + DEntrhs(p.I) += calcupdate_hydro(gf_fDEnt, p); momxrhs(p.I) += calcupdate_hydro(gf_fmomx, p); momyrhs(p.I) += calcupdate_hydro(gf_fmomy, p); momzrhs(p.I) += calcupdate_hydro(gf_fmomz, p); diff --git a/AsterX/src/source.cxx b/AsterX/src/source.cxx index bf81db2e..7ded0a5f 100644 --- a/AsterX/src/source.cxx +++ b/AsterX/src/source.cxx @@ -159,7 +159,7 @@ template void SourceTerms(CCTK_ARGUMENTS) { /* Update the RHS grid functions */ densrhs(p.I) = 0.0; - sstarrhs(p.I) = 0.0; + DEntrhs(p.I) = 0.0; momxrhs(p.I) = alp_avg * sqrt_detg * mom_source(0); momyrhs(p.I) = alp_avg * sqrt_detg * mom_source(1); momzrhs(p.I) = alp_avg * sqrt_detg * mom_source(2); diff --git a/Con2PrimFactory/src/atmo.hxx b/Con2PrimFactory/src/atmo.hxx index 551cce54..36c7fce5 100644 --- a/Con2PrimFactory/src/atmo.hxx +++ b/Con2PrimFactory/src/atmo.hxx @@ -71,7 +71,7 @@ struct atmosphere { cv.mom(1) = 0.0; cv.mom(2) = 0.0; cv.dYe = cv.dens * ye_atmo; - cv.dS = cv.dens * entropy_atmo; + cv.DEnt = cv.dens * entropy_atmo; const vec &B_up = pv.Bvec; const vec B_low = calc_contraction(g, B_up); CCTK_REAL Bsq = calc_contraction(B_up, B_low); diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index be8781ef..681d5860 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -132,7 +132,7 @@ c2p_1DEntropy::xEntropyToPrim(CCTK_REAL xEntropy_Sol, CCTK_REAL Ssq, const smat &glo) const { // Density, entropy, Ye pv.rho = xEntropy_Sol; - pv.entropy = cv.dS / cv.dens; + pv.entropy = cv.DEnt / cv.dens; pv.Ye = cv.dYe / cv.dens; // Lorentz factor @@ -213,10 +213,10 @@ c2p_1DEntropy::funcRoot_1DEntropy(CCTK_REAL Ssq, CCTK_REAL Bsq, CCTK_REAL BiSi, CCTK_REAL x, const EOSType &eos_th, const cons_vars &cv) const { - // We already divided dens, dS and + // We already divided dens, DEnt and // dYe by sqrt(gamma) - const CCTK_REAL ent_loc = cv.dS / cv.dens; + const CCTK_REAL ent_loc = cv.DEnt / cv.dens; const CCTK_REAL ye_loc = cv.dYe / cv.dens; // Compute h using entropy @@ -285,7 +285,7 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, cv.mom /= sqrt_detg; cv.dBvec /= sqrt_detg; cv.dYe /= sqrt_detg; - cv.dS /= sqrt_detg; + cv.DEnt /= sqrt_detg; if (cv.dens <= atmo.rho_cut) { rep.set_atmo_set(); @@ -299,7 +299,7 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, // TODO: Is this check really necessary? if ( (!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || - (!isfinite(BiSi)) || (!isfinite(cv.dYe)) || (!isfinite(cv.dS)) ) { + (!isfinite(BiSi)) || (!isfinite(cv.dYe)) || (!isfinite(cv.DEnt)) ) { rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); set_to_nan(pv, cv); return; @@ -365,7 +365,7 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, cv_check.mom /= sqrt_detg; cv_check.dBvec /= sqrt_detg; cv_check.dYe /= sqrt_detg; - cv_check.dS /= sqrt_detg; + cv_check.DEnt /= sqrt_detg; CCTK_REAL small = 1e-50; @@ -414,7 +414,7 @@ c2p_1DEntropy::solve(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, cv.mom *= sqrt_detg; cv.dBvec *= sqrt_detg; cv.dYe *= sqrt_detg; - cv.dS *= sqrt_detg; + cv.DEnt *= sqrt_detg; } } diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 12cc8527..d14dc7b7 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -310,7 +310,7 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, cv.mom /= sqrt_detg; cv.dBvec /= sqrt_detg; cv.dYe /= sqrt_detg; - cv.dS /= sqrt_detg; + cv.DEnt /= sqrt_detg; if (cv.dens <= atmo.rho_cut) { rep.set_atmo_set(); @@ -324,7 +324,7 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, // TODO: Is this check really necessary? if ( (!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || - (!isfinite(BiSi)) || (!isfinite(cv.dYe)) || (!isfinite(cv.dS)) ) { + (!isfinite(BiSi)) || (!isfinite(cv.dYe)) || (!isfinite(cv.DEnt)) ) { rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); set_to_nan(pv, cv); return; @@ -400,7 +400,7 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, cv_check.mom /= sqrt_detg; cv_check.dBvec /= sqrt_detg; cv_check.dYe /= sqrt_detg; - cv_check.dS /= sqrt_detg; + cv_check.DEnt /= sqrt_detg; CCTK_REAL small = 1e-50; @@ -439,7 +439,7 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, cv.mom *= sqrt_detg; cv.dBvec *= sqrt_detg; cv.dYe *= sqrt_detg; - cv.dS *= sqrt_detg; + cv.DEnt *= sqrt_detg; } } diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index cacbfead..2cb61a78 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -301,7 +301,7 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cv.mom /= sqrt_detg; cv.dBvec /= sqrt_detg; cv.dYe /= sqrt_detg; - cv.dS /= sqrt_detg; + cv.DEnt /= sqrt_detg; if (cv.dens <= atmo.rho_cut) { rep.set_atmo_set(); @@ -343,7 +343,7 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, // TODO: Is this check really necessary? if ( (!isfinite(cv.dens)) || (!isfinite(Ssq)) || (!isfinite(Bsq)) || - (!isfinite(BiSi)) || (!isfinite(cv.dYe)) || (!isfinite(cv.dS)) ) { + (!isfinite(BiSi)) || (!isfinite(cv.dYe)) || (!isfinite(cv.DEnt)) ) { rep.set_nans_in_cons(cv.dens, Ssq, Bsq, BiSi, cv.dYe); set_to_nan(pv, cv); return; @@ -544,7 +544,7 @@ c2p_2DNoble::solve(const EOSType &eos_th, prim_vars &pv, prim_vars &pv_seeds, cv.mom *= sqrt_detg; cv.dBvec *= sqrt_detg; cv.dYe *= sqrt_detg; - cv.dS *= sqrt_detg; + cv.DEnt *= sqrt_detg; } } diff --git a/Con2PrimFactory/src/cons.hxx b/Con2PrimFactory/src/cons.hxx index ef103dee..1067af04 100644 --- a/Con2PrimFactory/src/cons.hxx +++ b/Con2PrimFactory/src/cons.hxx @@ -17,7 +17,7 @@ struct cons_vars { vec mom; CCTK_REAL tau; CCTK_REAL dYe; - CCTK_REAL dS; + CCTK_REAL DEnt; vec dBvec; // Default constructor, no initialization. @@ -25,9 +25,9 @@ struct cons_vars { // Construct from single variables. CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline cons_vars( - CCTK_REAL dens_, vec mom_, CCTK_REAL tau_, CCTK_REAL dYe_, CCTK_REAL dS_, + CCTK_REAL dens_, vec mom_, CCTK_REAL tau_, CCTK_REAL dYe_, CCTK_REAL DEnt_, vec dBvec_) - : dens{dens_}, mom{mom_}, tau{tau_}, dYe{dYe_}, dS{dS_}, dBvec{dBvec_} {} + : dens{dens_}, mom{mom_}, tau{tau_}, dYe{dYe_}, DEnt{DEnt_}, dBvec{dBvec_} {} /// Copy assignment CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline cons_vars & @@ -39,7 +39,7 @@ struct cons_vars { mom = other.mom; tau = other.tau; dYe = other.dYe; - dS = other.dS; + DEnt = other.DEnt; dBvec = other.dBvec; return *this; } @@ -85,12 +85,12 @@ struct cons_vars { dBvec = sqrt_detg * pv.Bvec; dYe = dens * pv.Ye; - dS = dens * pv.entropy; + DEnt = dens * pv.entropy; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void scatter(CCTK_REAL &dens_, CCTK_REAL &momx_, CCTK_REAL &momy_, - CCTK_REAL &momz_, CCTK_REAL &tau_, CCTK_REAL &dYe_, CCTK_REAL &dS_, + CCTK_REAL &momz_, CCTK_REAL &tau_, CCTK_REAL &dYe_, CCTK_REAL &DEnt_, CCTK_REAL &dBvecx_, CCTK_REAL &dBvecy_, CCTK_REAL &dBvecz_) const { dens_ = dens; @@ -99,14 +99,14 @@ struct cons_vars { momz_ = mom(2); tau_ = tau; dYe_ = dYe; - dS_ = dS; + DEnt_ = DEnt; dBvecx_ = dBvec(0); dBvecy_ = dBvec(1); dBvecz_ = dBvec(2); } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void set_to_nan() { - dens = mom(0) = mom(1) = mom(2) = tau = dYe = dS = dBvec(0) = dBvec(1) = + dens = mom(0) = mom(1) = mom(2) = tau = dYe = DEnt = dBvec(0) = dBvec(1) = dBvec(2) = std::numeric_limits::quiet_NaN(); } }; diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index 36d14c5e..b97b6ce4 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -117,9 +117,9 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "dBx: %f \n" "dBy: %f \n" "dBz: %f \n" - "dS: %f \n", + "DEnt: %f \n", cv_all.dens, cv_all.tau, cv_all.mom(0), cv_all.mom(1), cv_all.mom(2), cv_all.dYe, cv_all.dBvec(0), - cv_all.dBvec(1), cv_all.dBvec(2), cv_all.dS); + cv_all.dBvec(1), cv_all.dBvec(2), cv_all.DEnt); /* assert(pv.rho == pv_seeds.rho); assert(pv.eps == pv_seeds.eps); @@ -162,9 +162,9 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "dBx: %f \n" "dBy: %f \n" "dBz: %f \n" - "dS: %f \n", + "DEnt: %f \n", cv_all.dens, cv_all.tau, cv_all.mom(0), cv_all.mom(1), cv_all.mom(2), cv_all.dYe, cv_all.dBvec(0), - cv_all.dBvec(1), cv_all.dBvec(2), cv_all.dS); + cv_all.dBvec(1), cv_all.dBvec(2), cv_all.DEnt); /* assert(pv.rho == pv_seeds.rho); assert(pv.eps == pv_seeds.eps); @@ -205,9 +205,9 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { "dBx: %f \n" "dBy: %f \n" "dBz: %f \n" - "dS: %f \n", + "DEnt: %f \n", cv_all.dens, cv_all.tau, cv_all.mom(0), cv_all.mom(1), cv_all.mom(2), cv_all.dYe, cv_all.dBvec(0), - cv_all.dBvec(1), cv_all.dBvec(2), cv_all.dS); + cv_all.dBvec(1), cv_all.dBvec(2), cv_all.DEnt); /* assert(pv.rho == pv_seeds.rho); assert(pv.eps == pv_seeds.eps); From 83988380ca11ee81b3cd14ed2ebd8227e45b5463 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Tue, 26 Nov 2024 10:50:17 -0600 Subject: [PATCH 46/50] Con2PrimFactory: Make BH parameters accessible, compiling version, not tested --- AsterX/src/con2prim.cxx | 13 ++++++++----- Con2PrimFactory/src/c2p.hxx | 13 ++++++++++--- Con2PrimFactory/src/c2p_1DEntropy.hxx | 17 ++++++++++++----- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 17 ++++++++++++----- Con2PrimFactory/src/c2p_2DNoble.hxx | 17 ++++++++++++----- Con2PrimFactory/src/test.cxx | 17 ++++++++++++----- 6 files changed, 66 insertions(+), 28 deletions(-) diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index ad773634..e4039684 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -61,8 +61,8 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, const PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE { // Note that HydroBaseX gfs are NaN when entering this loop due - // explicit dependence on conservatives from AsterX -> - // dependents tag + // explicit dependence on conservatives from + // AsterX -> dependents tag // Setting up atmosphere CCTK_REAL rho_atm = 0.0; // dummy initialization @@ -93,15 +93,18 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, // Construct Noble c2p object: c2p_2DNoble c2p_Noble(eos_th, atmo, max_iter, c2p_tol, rho_strict, vw_lim, - B_lim, Ye_lenient, cons_error_limit, use_z); + B_lim, Ye_lenient, cons_error_limit, use_z, + alp_thresh, rho_BH, eps_BH, vwlim_BH); // Construct Palenzuela c2p object: c2p_1DPalenzuela c2p_Pal(eos_th, atmo, max_iter, c2p_tol, rho_strict, - vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z); + vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, + alp_thresh, rho_BH, eps_BH, vwlim_BH); // Construct Entropy c2p object: c2p_1DEntropy c2p_Ent(eos_th, atmo, max_iter, c2p_tol, rho_strict, - vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z); + vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, + alp_thresh, rho_BH, eps_BH, vwlim_BH); /* Get covariant metric */ const smat glo( diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index 51c5f662..d0b63018 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -48,6 +48,11 @@ protected: atmosphere atmo; CCTK_REAL cons_error; bool use_zprim; + // Parameters for BH interiors + CCTK_REAL alp_thresh; + CCTK_REAL rho_BH; + CCTK_REAL eps_BH; + CCTK_REAL vwlim_BH; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, @@ -66,6 +71,8 @@ protected: prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_vars &cv, const smat &glo, c2p_report &rep) const; + public: + template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline void bh_interior_fail(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, @@ -179,11 +186,11 @@ c2p::bh_interior_fail(const EOSType &eos_th, prim_vars &pv, cons_vars &cv, pv.rho = rho_BH; // typically set to 0.01% to 1% of rho_max of initial // NS or disk pv.eps = eps_BH; - pv.Ye = Ye_atmo; + pv.Ye = 0.5; pv.press = - eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); + eos_th.press_from_valid_rho_eps_ye(rho_BH, eps_BH, 0.5); pv.entropy = - eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, Ye_atmo); + eos_th.kappa_from_valid_rho_eps_ye(rho_BH, eps_BH, 0.5); // check on velocities CCTK_REAL wlim_BH = sqrt(1.0 + vwlim_BH * vwlim_BH); CCTK_REAL vlim_BH = vwlim_BH / wlim_BH; diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 681d5860..7d812f9f 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -15,8 +15,8 @@ public: CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, - bool use_z); + CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, + CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, const smat &gup) const; @@ -57,10 +57,10 @@ CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, - bool use_z) { + CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, + CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in) { - GammaIdealFluid = eos_th.gamma; + // Base maxIterations = maxIter; tolerance = tol; rho_strict = rho_str; @@ -72,6 +72,13 @@ CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( atmo = atm; cons_error = consError; use_zprim = use_z; + alp_thresh = alp_thresh_in; + rho_BH = rho_BH_in; + eps_BH = eps_BH_in; + vwlim_BH = vwlim_BH_in; + + // Derived + GammaIdealFluid = eos_th.gamma; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index d14dc7b7..67a73f33 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -16,8 +16,8 @@ public: CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, - bool use_z); + CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, + CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, @@ -61,10 +61,10 @@ CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::c2p_1DPalenzuela( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, - bool use_z) { + CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, + CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in) { - GammaIdealFluid = eos_th.gamma; + // Base maxIterations = maxIter; tolerance = tol; rho_strict = rho_str; @@ -76,6 +76,13 @@ CCTK_HOST CCTK_DEVICE atmo = atm; cons_error = consError; use_zprim = use_z; + alp_thresh = alp_thresh_in; + rho_BH = rho_BH_in; + eps_BH = eps_BH_in; + vwlim_BH = vwlim_BH_in; + + // Derived + GammaIdealFluid = eos_th.gamma; } CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 2cb61a78..8a5ef817 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -18,8 +18,8 @@ public: CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, - bool use_z); + CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, + CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, @@ -73,10 +73,10 @@ CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble::c2p_2DNoble( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, - bool use_z) { + CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, + CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in) { - GammaIdealFluid = eos_th.gamma; + // Base maxIterations = maxIter; tolerance = tol; rho_strict = rho_str; @@ -88,6 +88,13 @@ CCTK_HOST atmo = atm; cons_error = consError; use_zprim = use_z; + alp_thresh = alp_thresh_in; + rho_BH = rho_BH_in; + eps_BH = eps_BH_in; + vwlim_BH = vwlim_BH_in; + + // Derived + GammaIdealFluid = eos_th.gamma; Zmin = eos_th.rgrho.min; } diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index b97b6ce4..9a9e73ac 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -41,12 +41,19 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { const smat g{1.0, 0.0, 0.0, 1.0, 0.0, 1.0}; // xx, xy, xz, yy, yz, zz + // Set BH limiters + const CCTK_REAL alp_thresh = -1.; + const CCTK_REAL rho_BH = 1e20; + const CCTK_REAL eps_BH = 1e20; + const CCTK_REAL vwlim_BH = 1e20; + // Con2Prim objects // (eos_th, atmo, max_iter, c2p_tol, rho_strict, - // vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z) - c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false); - c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false); - c2p_1DEntropy c2p_Ent(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false); + // vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, alp_thresh, + // rho_BH, eps_BH, vwlim_BH) + c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); + c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); + c2p_1DEntropy c2p_Ent(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); // Construct error report object: c2p_report rep_Noble; @@ -69,7 +76,7 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { prim_vars pv_seeds{rho_in, eps_in, Ye_in, press_in, entropy_in, vup_in, wlor_in, Bup_in}; // cons_vars cv{dens(p.I), {momx(p.I), momy(p.I), momz(p.I)}, tau(p.I), - // dummy_dYe, {dBx(p.I), dBy(p.I), dBz(p.I)}}; + // dummy_dYe, DEnt, {dBx(p.I), dBy(p.I), dBz(p.I)}}; cons_vars cv_Noble; cons_vars cv_Pal; From fe01ad6801f96355222667d1e261fe1170599d0a Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Tue, 26 Nov 2024 15:10:51 -0600 Subject: [PATCH 47/50] Con2PrimFactory: Add comment on safety against non-finite values without explicit checks --- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index 67a73f33..c8874a4d 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -394,6 +394,20 @@ c2p_1DPalenzuela::solve(const EOSType &eos_th, prim_vars &pv, xPalenzuelaToPrim(xPalenzuela_Sol, Ssq, Bsq, BiSi, eos_th, pv, cv, gup, glo); + + // General comment: + // One could think of expressing the following condition + // in a way that is "safe" against NaNs and infs. First, this only makes + // sense if we want these values to be considered as failures which should + // be treated as "not converged". + // + // inf: Since inf behaves like a large valid number nothing special needs + // to be done except of rewriting the argument of the if condition such that + // possible infs are present only on one side of the comparison, eg + // abs(difference)/abs(normalization) > tolerance_0 + // + // NaN: If the argument of if (...) is NaN, it usually evaluates to false. + // Here, we would need to rewrite the logic a little bit. if (abs(result.first - result.second) > tolerance_0 * min(abs(result.first), abs(result.second))) { From 83084bb79f3207ce84f451b8e8c9fb6293451a54 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Tue, 26 Nov 2024 15:41:27 -0600 Subject: [PATCH 48/50] AsterX: Remove rho-strict --- AsterX/par/Scaling_magTOV_Z4c_unigrid.par | 1 - AsterX/par/magTOV_Cowling_unigrid.par | 1 - AsterX/par/magTOV_Z4c_AMR.par | 1 - AsterX/param.ccl | 1 - AsterX/src/con2prim.cxx | 6 +++--- AsterX/src/con2prim_rpa.cxx | 2 +- Con2PrimFactory/param.ccl | 6 ------ Con2PrimFactory/src/c2p.hxx | 9 ++++----- Con2PrimFactory/src/c2p_1DEntropy.hxx | 5 ++--- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 5 ++--- Con2PrimFactory/src/c2p_2DNoble.hxx | 5 ++--- Con2PrimFactory/src/test.cxx | 8 ++++---- 12 files changed, 18 insertions(+), 32 deletions(-) diff --git a/AsterX/par/Scaling_magTOV_Z4c_unigrid.par b/AsterX/par/Scaling_magTOV_Z4c_unigrid.par index 160e87e9..d3c06b68 100644 --- a/AsterX/par/Scaling_magTOV_Z4c_unigrid.par +++ b/AsterX/par/Scaling_magTOV_Z4c_unigrid.par @@ -110,7 +110,6 @@ Con2PrimFactory::unit_test = "yes" Con2PrimFactory::B_lim = 1e8 Con2PrimFactory::vw_lim = 1e8 Con2PrimFactory::Ye_lenient = "yes" -Con2PrimFactory::rho_strict = 6.4e-05 EOSX::evolution_eos = "IdealGas" EOSX::gl_gamma = 2.0 diff --git a/AsterX/par/magTOV_Cowling_unigrid.par b/AsterX/par/magTOV_Cowling_unigrid.par index 18d8d9fc..99fa72c8 100644 --- a/AsterX/par/magTOV_Cowling_unigrid.par +++ b/AsterX/par/magTOV_Cowling_unigrid.par @@ -110,7 +110,6 @@ Con2PrimFactory::unit_test = "yes" Con2PrimFactory::B_lim = 1e8 Con2PrimFactory::vw_lim = 1e8 Con2PrimFactory::Ye_lenient = "yes" -Con2PrimFactory::rho_strict = 6.4e-05 EOSX::evolution_eos = "IdealGas" EOSX::gl_gamma = 2.0 diff --git a/AsterX/par/magTOV_Z4c_AMR.par b/AsterX/par/magTOV_Z4c_AMR.par index 9cb9bb28..fabf226a 100644 --- a/AsterX/par/magTOV_Z4c_AMR.par +++ b/AsterX/par/magTOV_Z4c_AMR.par @@ -121,7 +121,6 @@ Con2PrimFactory::unit_test = "yes" Con2PrimFactory::B_lim = 1e8 Con2PrimFactory::vw_lim = 1e8 Con2PrimFactory::Ye_lenient = "yes" -Con2PrimFactory::rho_strict = 6.4e-05 EOSX::evolution_eos = "IdealGas" EOSX::gl_gamma = 2.0 diff --git a/AsterX/param.ccl b/AsterX/param.ccl index b2f988b6..71c46f38 100644 --- a/AsterX/param.ccl +++ b/AsterX/param.ccl @@ -112,7 +112,6 @@ USES CCTK_REAL p_atmo USES CCTK_REAL Ye_atmo USES CCTK_REAL B_lim USES CCTK_REAL vw_lim -USES CCTK_REAL rho_strict USES BOOLEAN Ye_lenient USES CCTK_INT max_iter USES CCTK_REAL c2p_tol diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index e4039684..fbdfec9b 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -92,17 +92,17 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, atmosphere atmo(rho_atm, eps_atm, Ye_atmo, press_atm, entropy_atm, rho_atmo_cut); // Construct Noble c2p object: - c2p_2DNoble c2p_Noble(eos_th, atmo, max_iter, c2p_tol, rho_strict, vw_lim, + c2p_2DNoble c2p_Noble(eos_th, atmo, max_iter, c2p_tol, vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, alp_thresh, rho_BH, eps_BH, vwlim_BH); // Construct Palenzuela c2p object: - c2p_1DPalenzuela c2p_Pal(eos_th, atmo, max_iter, c2p_tol, rho_strict, + c2p_1DPalenzuela c2p_Pal(eos_th, atmo, max_iter, c2p_tol, vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, alp_thresh, rho_BH, eps_BH, vwlim_BH); // Construct Entropy c2p object: - c2p_1DEntropy c2p_Ent(eos_th, atmo, max_iter, c2p_tol, rho_strict, + c2p_1DEntropy c2p_Ent(eos_th, atmo, max_iter, c2p_tol, vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, alp_thresh, rho_BH, eps_BH, vwlim_BH); diff --git a/AsterX/src/con2prim_rpa.cxx b/AsterX/src/con2prim_rpa.cxx index 30dbee8b..d9b5dff8 100644 --- a/AsterX/src/con2prim_rpa.cxx +++ b/AsterX/src/con2prim_rpa.cxx @@ -74,7 +74,7 @@ extern "C" void AsterX_Con2Prim(CCTK_ARGUMENTS) { CCTK_REAL dummy_dYe = 0.5; // Get a recovery function - con2prim_mhd cv2pv(eos, rho_strict, Ye_lenient, vw_lim, B_lim, atmo, + con2prim_mhd cv2pv(eos, 1.0e5, Ye_lenient, vw_lim, B_lim, atmo, c2p_tol, max_iter); /* Get covariant metric */ diff --git a/Con2PrimFactory/param.ccl b/Con2PrimFactory/param.ccl index 0b3d90c9..b0d8b179 100644 --- a/Con2PrimFactory/param.ccl +++ b/Con2PrimFactory/param.ccl @@ -52,12 +52,6 @@ CCTK_REAL vw_lim "Upper limit for the value of velocity * lorentz_factor " STEER 0: :: "Must be positive" } 10.0 -# TODO: Change name -CCTK_REAL rho_strict "Density ceiling after C2P" STEERABLE=ALWAYS -{ - 0: :: "Must be positive" -} 1e100 - BOOLEAN Ye_lenient "Whether to allow restricting Y_e to a valid range" STEERABLE=ALWAYS { } "no" diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index d0b63018..85ff5879 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -39,7 +39,6 @@ protected: CCTK_INT maxIterations; CCTK_REAL tolerance; - CCTK_REAL rho_strict; bool ye_lenient; CCTK_REAL v_lim; CCTK_REAL w_lim; @@ -122,13 +121,13 @@ c2p::prims_floors_and_ceilings(const EOSType &eos_th, prim_vars &pv, const cons_ rep.adjust_cons = true; } - if (pv.rho > rho_strict) { + if (pv.rho > eos_th.rgrho.max) { // remove mass, changes conserved density D - pv.rho = rho_strict; - pv.eps = eos_th.eps_from_valid_rho_press_ye(rho_strict, pv.press, pv.Ye); + pv.rho = eos_th.rgrho.max; + pv.eps = eos_th.eps_from_valid_rho_press_ye(eos_th.rgrho.max, pv.press, pv.Ye); pv.entropy = - eos_th.kappa_from_valid_rho_eps_ye(rho_strict, pv.eps, pv.Ye); + eos_th.kappa_from_valid_rho_eps_ye(eos_th.rgrho.max, pv.eps, pv.Ye); rep.adjust_cons = true; } diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 7d812f9f..5b9240b2 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -14,7 +14,7 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in); @@ -56,14 +56,13 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in) { // Base maxIterations = maxIter; tolerance = tol; - rho_strict = rho_str; ye_lenient = ye_len; vw_lim = vwlim; w_lim = sqrt(1.0 + vw_lim * vw_lim); diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index c8874a4d..ba803957 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -15,7 +15,7 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in); @@ -60,14 +60,13 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::c2p_1DPalenzuela( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in) { // Base maxIterations = maxIter; tolerance = tol; - rho_strict = rho_str; ye_lenient = ye_len; vw_lim = vwlim; w_lim = sqrt(1.0 + vw_lim * vw_lim); diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 8a5ef817..4f0efad2 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -17,7 +17,7 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in); @@ -72,14 +72,13 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble::c2p_2DNoble( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL rho_str, CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, + CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in) { // Base maxIterations = maxIter; tolerance = tol; - rho_strict = rho_str; ye_lenient = ye_len; vw_lim = vwlim; w_lim = sqrt(1.0 + vw_lim * vw_lim); diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index 9a9e73ac..fe5fb004 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -48,12 +48,12 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { const CCTK_REAL vwlim_BH = 1e20; // Con2Prim objects - // (eos_th, atmo, max_iter, c2p_tol, rho_strict, + // (eos_th, atmo, max_iter, c2p_tol, // vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, alp_thresh, // rho_BH, eps_BH, vwlim_BH) - c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); - c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); - c2p_1DEntropy c2p_Ent(eos_th, atmo, 100, 1e-8, 1e8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); + c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); + c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); + c2p_1DEntropy c2p_Ent(eos_th, atmo, 100, 1e-8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); // Construct error report object: c2p_report rep_Noble; From 1ee3a88903aa9de12d7ed842d4fe4b3575133672 Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Tue, 26 Nov 2024 17:19:30 -0600 Subject: [PATCH 49/50] AsterX: Final changes, remove EntropyInitial, change C2P interface, minor changes --- AsterX/src/con2prim.cxx | 23 ++++++++------ Con2PrimFactory/src/c2p.hxx | 15 +++++---- Con2PrimFactory/src/c2p_1DEntropy.hxx | 26 ++++++++-------- Con2PrimFactory/src/c2p_1DPalenzuela.hxx | 24 +++++++-------- Con2PrimFactory/src/c2p_2DNoble.hxx | 24 +++++++-------- Con2PrimFactory/src/test.cxx | 13 ++++---- EOSX/param.ccl | 2 +- EntropyInitial/LICENSE | 25 --------------- EntropyInitial/configuration.ccl | 1 - EntropyInitial/interface.ccl | 7 ----- EntropyInitial/param.ccl | 12 -------- EntropyInitial/schedule.ccl | 9 ------ EntropyInitial/src/SetEntropy.cxx | 39 ------------------------ EntropyInitial/src/make.code.defn | 1 - 14 files changed, 65 insertions(+), 156 deletions(-) delete mode 100644 EntropyInitial/LICENSE delete mode 100644 EntropyInitial/configuration.ccl delete mode 100644 EntropyInitial/interface.ccl delete mode 100644 EntropyInitial/param.ccl delete mode 100644 EntropyInitial/schedule.ccl delete mode 100644 EntropyInitial/src/SetEntropy.cxx delete mode 100644 EntropyInitial/src/make.code.defn diff --git a/AsterX/src/con2prim.cxx b/AsterX/src/con2prim.cxx index fbdfec9b..5fc2d4fd 100644 --- a/AsterX/src/con2prim.cxx +++ b/AsterX/src/con2prim.cxx @@ -92,19 +92,22 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, atmosphere atmo(rho_atm, eps_atm, Ye_atmo, press_atm, entropy_atm, rho_atmo_cut); // Construct Noble c2p object: - c2p_2DNoble c2p_Noble(eos_th, atmo, max_iter, c2p_tol, vw_lim, - B_lim, Ye_lenient, cons_error_limit, use_z, - alp_thresh, rho_BH, eps_BH, vwlim_BH); + c2p_2DNoble c2p_Noble(eos_th, atmo, max_iter, c2p_tol, + alp_thresh, cons_error_limit, + vw_lim, B_lim, rho_BH, eps_BH, vwlim_BH, + Ye_lenient, use_z); // Construct Palenzuela c2p object: - c2p_1DPalenzuela c2p_Pal(eos_th, atmo, max_iter, c2p_tol, - vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, - alp_thresh, rho_BH, eps_BH, vwlim_BH); + c2p_1DPalenzuela c2p_Pal(eos_th, atmo, max_iter, c2p_tol, + alp_thresh, cons_error_limit, + vw_lim, B_lim, rho_BH, eps_BH, vwlim_BH, + Ye_lenient, use_z); // Construct Entropy c2p object: - c2p_1DEntropy c2p_Ent(eos_th, atmo, max_iter, c2p_tol, - vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, - alp_thresh, rho_BH, eps_BH, vwlim_BH); + c2p_1DEntropy c2p_Ent(eos_th, atmo, max_iter, c2p_tol, + alp_thresh, cons_error_limit, + vw_lim, B_lim, rho_BH, eps_BH, vwlim_BH, + Ye_lenient, use_z); /* Get covariant metric */ const smat glo( @@ -253,7 +256,7 @@ void AsterX_Con2Prim_typeEoS(CCTK_ARGUMENTS, EOSIDType &eos_cold, Avec_x(p.I), Avec_y(p.I), Avec_z(p.I)); } - if ( (alp(p.I) < alp_thresh) && ( (pv_seeds.rho > rho_BH) || (pv_seeds.eps > eps_BH) ) ) { + if ( (alp(p.I) < alp_thresh) ) { c2p_Noble.bh_interior_fail(eos_th,pv,cv,glo); } else { // set to atmo diff --git a/Con2PrimFactory/src/c2p.hxx b/Con2PrimFactory/src/c2p.hxx index 85ff5879..ec7bdacf 100644 --- a/Con2PrimFactory/src/c2p.hxx +++ b/Con2PrimFactory/src/c2p.hxx @@ -37,21 +37,20 @@ class c2p { protected: /* The constructor must initialize the following variables */ + atmosphere atmo; CCTK_INT maxIterations; CCTK_REAL tolerance; - bool ye_lenient; - CCTK_REAL v_lim; - CCTK_REAL w_lim; + CCTK_REAL alp_thresh; + CCTK_REAL cons_error; CCTK_REAL vw_lim; + CCTK_REAL w_lim; + CCTK_REAL v_lim; CCTK_REAL Bsq_lim; - atmosphere atmo; - CCTK_REAL cons_error; - bool use_zprim; - // Parameters for BH interiors - CCTK_REAL alp_thresh; CCTK_REAL rho_BH; CCTK_REAL eps_BH; CCTK_REAL vwlim_BH; + bool ye_lenient; + bool use_zprim; CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, diff --git a/Con2PrimFactory/src/c2p_1DEntropy.hxx b/Con2PrimFactory/src/c2p_1DEntropy.hxx index 5b9240b2..fdbaf1fd 100644 --- a/Con2PrimFactory/src/c2p_1DEntropy.hxx +++ b/Con2PrimFactory/src/c2p_1DEntropy.hxx @@ -13,10 +13,10 @@ public: /* Constructor */ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy( - const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, - CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in); + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + CCTK_REAL alp_thresh_in, CCTK_REAL consError, + CCTK_REAL vwlim, CCTK_REAL B_lim, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in, + bool ye_len, bool use_z); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, const smat &gup) const; @@ -55,26 +55,26 @@ public: template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DEntropy::c2p_1DEntropy( - const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, - CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in) { + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + CCTK_REAL alp_thresh_in, CCTK_REAL consError, + CCTK_REAL vwlim, CCTK_REAL B_lim, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in, + bool ye_len, bool use_z) { // Base + atmo = atm; maxIterations = maxIter; tolerance = tol; - ye_lenient = ye_len; + alp_thresh = alp_thresh_in; + cons_error = consError; vw_lim = vwlim; w_lim = sqrt(1.0 + vw_lim * vw_lim); v_lim = vw_lim / w_lim; Bsq_lim = B_lim * B_lim; - atmo = atm; - cons_error = consError; - use_zprim = use_z; - alp_thresh = alp_thresh_in; rho_BH = rho_BH_in; eps_BH = eps_BH_in; vwlim_BH = vwlim_BH_in; + ye_lenient = ye_len; + use_zprim = use_z; // Derived GammaIdealFluid = eos_th.gamma; diff --git a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx index ba803957..db53692c 100644 --- a/Con2PrimFactory/src/c2p_1DPalenzuela.hxx +++ b/Con2PrimFactory/src/c2p_1DPalenzuela.hxx @@ -14,10 +14,10 @@ public: /* Constructor */ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela( - const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, - CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in); + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + CCTK_REAL alp_thresh_in, CCTK_REAL consError, + CCTK_REAL vwlim, CCTK_REAL B_lim, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in, + bool ye_len, bool use_z); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, @@ -60,25 +60,25 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_1DPalenzuela::c2p_1DPalenzuela( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, - CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in) { + CCTK_REAL alp_thresh_in, CCTK_REAL consError, + CCTK_REAL vwlim, CCTK_REAL B_lim, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in, + bool ye_len, bool use_z) { // Base + atmo = atm; maxIterations = maxIter; tolerance = tol; - ye_lenient = ye_len; + alp_thresh = alp_thresh_in; + cons_error = consError; vw_lim = vwlim; w_lim = sqrt(1.0 + vw_lim * vw_lim); v_lim = vw_lim / w_lim; Bsq_lim = B_lim * B_lim; - atmo = atm; - cons_error = consError; - use_zprim = use_z; - alp_thresh = alp_thresh_in; rho_BH = rho_BH_in; eps_BH = eps_BH_in; vwlim_BH = vwlim_BH_in; + ye_lenient = ye_len; + use_zprim = use_z; // Derived GammaIdealFluid = eos_th.gamma; diff --git a/Con2PrimFactory/src/c2p_2DNoble.hxx b/Con2PrimFactory/src/c2p_2DNoble.hxx index 4f0efad2..b3f2a694 100644 --- a/Con2PrimFactory/src/c2p_2DNoble.hxx +++ b/Con2PrimFactory/src/c2p_2DNoble.hxx @@ -16,10 +16,10 @@ public: /* Constructor */ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble( - const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, - CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in); + const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, + CCTK_REAL alp_thresh_in, CCTK_REAL consError, + CCTK_REAL vwlim, CCTK_REAL B_lim, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in, + bool ye_len, bool use_z); CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline CCTK_REAL get_Ssq_Exact(const vec &mom, @@ -72,25 +72,25 @@ template CCTK_HOST CCTK_DEVICE CCTK_ATTRIBUTE_ALWAYS_INLINE inline c2p_2DNoble::c2p_2DNoble( const EOSType &eos_th, const atmosphere &atm, CCTK_INT maxIter, CCTK_REAL tol, - CCTK_REAL vwlim, CCTK_REAL B_lim, bool ye_len, - CCTK_REAL consError, bool use_z, CCTK_REAL alp_thresh_in, - CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in) { + CCTK_REAL alp_thresh_in, CCTK_REAL consError, + CCTK_REAL vwlim, CCTK_REAL B_lim, CCTK_REAL rho_BH_in, CCTK_REAL eps_BH_in, CCTK_REAL vwlim_BH_in, + bool ye_len, bool use_z) { // Base + atmo = atm; maxIterations = maxIter; tolerance = tol; - ye_lenient = ye_len; + alp_thresh = alp_thresh_in; + cons_error = consError; vw_lim = vwlim; w_lim = sqrt(1.0 + vw_lim * vw_lim); v_lim = vw_lim / w_lim; Bsq_lim = B_lim * B_lim; - atmo = atm; - cons_error = consError; - use_zprim = use_z; - alp_thresh = alp_thresh_in; rho_BH = rho_BH_in; eps_BH = eps_BH_in; vwlim_BH = vwlim_BH_in; + ye_lenient = ye_len; + use_zprim = use_z; // Derived GammaIdealFluid = eos_th.gamma; diff --git a/Con2PrimFactory/src/test.cxx b/Con2PrimFactory/src/test.cxx index fe5fb004..e1dc4bbd 100644 --- a/Con2PrimFactory/src/test.cxx +++ b/Con2PrimFactory/src/test.cxx @@ -48,12 +48,13 @@ extern "C" void Con2PrimFactory_Test(CCTK_ARGUMENTS) { const CCTK_REAL vwlim_BH = 1e20; // Con2Prim objects - // (eos_th, atmo, max_iter, c2p_tol, - // vw_lim, B_lim, Ye_lenient, cons_error_limit, use_z, alp_thresh, - // rho_BH, eps_BH, vwlim_BH) - c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); - c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); - c2p_1DEntropy c2p_Ent(eos_th, atmo, 100, 1e-8, 1, 1, true,-1.,false, alp_thresh, rho_BH, eps_BH, vwlim_BH); + // (eos_th, atmo, max_iter, c2p_tol + // alp_thresh, cons_error_limit, + // vw_lim, B_lim, rho_BH, eps_BH, vwlim_BH, + // Ye_lenient, use_z) + c2p_2DNoble c2p_Noble(eos_th, atmo, 100, 1e-8, alp_thresh, -1., 1, 1, rho_BH, eps_BH, vwlim_BH, true, false); + c2p_1DPalenzuela c2p_Pal(eos_th, atmo, 100, 1e-8, alp_thresh, -1., 1, 1, rho_BH, eps_BH, vwlim_BH, true, false); + c2p_1DEntropy c2p_Ent(eos_th, atmo, 100, 1e-8, alp_thresh, -1., 1, 1, rho_BH, eps_BH, vwlim_BH, true, false); // Construct error report object: c2p_report rep_Noble; diff --git a/EOSX/param.ccl b/EOSX/param.ccl index a3ab816e..ee1e09e6 100644 --- a/EOSX/param.ccl +++ b/EOSX/param.ccl @@ -36,7 +36,7 @@ CCTK_REAL rho_max "Validity region: max density" STEERABLE=RECOVER CCTK_REAL rho_min "Validity region: min density" STEERABLE=RECOVER { (0:* :: "" -} 1.0e-20 +} 1.0e-100 CCTK_REAL eps_max "Validity region: max internal specific energy" STEERABLE=RECOVER { diff --git a/EntropyInitial/LICENSE b/EntropyInitial/LICENSE deleted file mode 100644 index 846c6426..00000000 --- a/EntropyInitial/LICENSE +++ /dev/null @@ -1,25 +0,0 @@ -BSD 2-Clause License - -Copyright (c) 2019, Zachariah Etienne -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/EntropyInitial/configuration.ccl b/EntropyInitial/configuration.ccl deleted file mode 100644 index 1f778d56..00000000 --- a/EntropyInitial/configuration.ccl +++ /dev/null @@ -1 +0,0 @@ -REQUIRES Loop diff --git a/EntropyInitial/interface.ccl b/EntropyInitial/interface.ccl deleted file mode 100644 index 2dc06d3d..00000000 --- a/EntropyInitial/interface.ccl +++ /dev/null @@ -1,7 +0,0 @@ -IMPLEMENTS: EntropyInitial - -INHERITS: ADMBaseX HydroBaseX AsterX - -USES INCLUDE HEADER: loop_device.hxx -USES INCLUDE HEADER: eos.hxx -USES INCLUDE HEADER: eos_idealgas.hxx diff --git a/EntropyInitial/param.ccl b/EntropyInitial/param.ccl deleted file mode 100644 index bd81bbf3..00000000 --- a/EntropyInitial/param.ccl +++ /dev/null @@ -1,12 +0,0 @@ -SHARES: EOSX -USES KEYWORD evolution_eos -USES CCTK_REAL poly_gamma -USES CCTK_REAL poly_k -USES CCTK_REAL gl_gamma -USES CCTK_REAL eps_min -USES CCTK_REAL eps_max -USES CCTK_REAL rho_min -USES CCTK_REAL rho_max -USES CCTK_REAL ye_min -USES CCTK_REAL ye_max -USES CCTK_REAL particle_mass diff --git a/EntropyInitial/schedule.ccl b/EntropyInitial/schedule.ccl deleted file mode 100644 index f4cdeabc..00000000 --- a/EntropyInitial/schedule.ccl +++ /dev/null @@ -1,9 +0,0 @@ - -schedule SetEntropy IN HydroBaseX_PostInitial -{ - LANG: C - - READS: HydroBaseX::rho(everywhere) HydroBaseX::eps(everywhere) - WRITES: HydroBaseX::entropy(everywhere) - -} "Set initial entropy" diff --git a/EntropyInitial/src/SetEntropy.cxx b/EntropyInitial/src/SetEntropy.cxx deleted file mode 100644 index 0d41d670..00000000 --- a/EntropyInitial/src/SetEntropy.cxx +++ /dev/null @@ -1,39 +0,0 @@ -#include -#include - -#include -#include -#include - -#include -#include -#include - -#include "eos.hxx" -#include "eos_idealgas.hxx" - -extern "C" void SetEntropy(CCTK_ARGUMENTS) -{ - - using namespace EOSX; - - DECLARE_CCTK_ARGUMENTSX_SetEntropy; - DECLARE_CCTK_PARAMETERS; - - eos::range rgeps(eps_min, eps_max), rgrho(rho_min, rho_max), - rgye(ye_min, ye_max); - - const eos_idealgas eos_th(gl_gamma, particle_mass, rgeps, rgrho, rgye); - - CCTK_VINFO("Set the entropy!"); - - grid.loop_all_device<1, 1, 1>( - grid.nghostzones, - [=] CCTK_DEVICE(const Loop::PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE { - - entropy(p.I) = eos_th.kappa_from_valid_rho_eps_ye(rho(p.I),eps(p.I),1.0); - - }); -} - - diff --git a/EntropyInitial/src/make.code.defn b/EntropyInitial/src/make.code.defn deleted file mode 100644 index ff556b89..00000000 --- a/EntropyInitial/src/make.code.defn +++ /dev/null @@ -1 +0,0 @@ -SRCS = SetEntropy.cxx From f01a14a8adc5198af6af3054ca24a0c99002bafd Mon Sep 17 00:00:00 2001 From: Michail Chabanov Date: Mon, 2 Dec 2024 10:56:29 -0600 Subject: [PATCH 50/50] AsterSeeds: Trivial test_type option, if ID written by another thorn --- AsterSeeds/param.ccl | 1 + 1 file changed, 1 insertion(+) diff --git a/AsterSeeds/param.ccl b/AsterSeeds/param.ccl index cfd328d1..b0cacbd8 100644 --- a/AsterSeeds/param.ccl +++ b/AsterSeeds/param.ccl @@ -2,6 +2,7 @@ KEYWORD test_type "Type of test to set up" STEERABLE=never { + "None" :: "Initial data should be written by another thorn" "1DTest" :: "" "2DTest" :: "" "3DTest" :: ""