def NR_TFromEpsRhoYe(eps_target,rho,Ye,max_its=100,rel_diff=1e-14,abs_diff=1e-15,T_guess=None,NR_fac=1.0):
if T_guess == None:
T_guess = 1.0
it=0
done=False
T_current = T_guess
eps_current = EOS_pressFromPrim(T_current,rho,Ye)
T_record = []
T_record.append(T_current)
success = False
while done == False:
depsdT = -EOS_dEdTFromPrim(T_current,rho,Ye)
root = eps_target-eps_current
delta_T = root/depsdT
T_current = T_current - NR_fac*delta_T
if T_current<10**log_T_array[0]:
T_current = 10**log_T_array[0]
elif T_current>10**log_T_array[-1]:
T_current = 10**log_T_array[-1]
eps_current = EOS_epsFromPrim(T_current,rho,Ye)
T_record.append(T_current)
it+=1
#if it>20 and it%20==0:
#T_current = np.average(np.array(T_record)[it-10:it])
if it>=max_its:
done = True
success = False
T_current = np.average(np.array(T_record)[-20:])
if np.abs(eps_target-eps_current)<abs_diff:
done = True
success = True
#print("Absolute convergence in " + str(it) + " iterations")
elif RelDiff(eps_target,eps_current)<rel_diff:
done = True
success = True
#print("Relative convergence in " + str(it) + " iterations")
return T_current, success, it
def GetWzTGuess(Cons_target, guesses):
D = Cons_target["D"]
DYe = Cons_target["DYe"]
Ye_found = DYe / D
if guesses == None:
W_guess = 1.0
T_guess = 1.0
else:
vsq_guess = guesses.vsq
W_guess = 1 / np.sqrt(1 - vsq_guess)
T_guess = guesses.T
rho_guess = D / W_guess
press_guess = EOS_pressFromPrim(T_guess, rho_guess, Ye_found)
eps_guess = EOS_epsFromPrim(T_guess, rho_guess, Ye_found)
h_guess = 1 + eps_guess + press_guess / rho_guess
z_guess = rho_guess * h_guess * (W_guess**2)
WzT_guess = {"W": W_guess, "z": z_guess, "T": T_guess}
return WzT_guess
def GuessFromTargets(targets,
min_frac=np.ones(3) * 0.98,
max_frac=np.ones(3) * 1.02):
guesses = Targets()
rho_target = targets.rho
rand = min_frac[0] + (max_frac[0] - min_frac[0]) * random()
guesses.rho = rho_target * rand
vsq_target = targets.vsq
rand = min_frac[1] + (max_frac[1] - min_frac[1]) * random()
guesses.vsq = vsq_target * rand
guesses.W = 1 / (np.sqrt(1 - guesses.vsq))
T_target = targets.T
rand = min_frac[2] + (max_frac[2] - min_frac[2]) * random()
guesses.T = T_target * rand
guesses.press = EOS_pressFromPrim(guesses.T, guesses.rho, targets.Ye)
guesses.eps = EOS_epsFromPrim(guesses.T, guesses.rho, targets.Ye)
guesses.h = 1 + guesses.eps + guesses.press / guesses.rho
guesses.z = guesses.h * guesses.rho * (guesses.W**2)
return guesses
def ConvergenceTest(targets, WzT, Cons_target, printTable=True):
W_target = targets.W
T_target = targets.T
h_target = targets.h
rho_target = targets.rho
press_target = targets.press
eps_target = targets.eps
v1_target = targets.v1
v2_target = targets.v2
v3_target = targets.v3
Ye_found = Cons_target["DYe"] / Cons_target["D"]
rho_found = Cons_target["D"] / WzT["W"]
T_found = WzT["T"]
v1_found = Cons_target["S_1"] / WzT["z"]
v2_found = Cons_target["S_2"] / WzT["z"]
v3_found = Cons_target["S_3"] / WzT["z"]
press_found = EOS_pressFromPrim(T_found, rho_found, Ye_found)
eps_found = EOS_epsFromPrim(T_found, rho_found, Ye_found)
gubs, Cons_found = GetInitialGuess(rho=rho_found,
velocity=np.array(
[v1_found, v2_found, v3_found]),
T=T_found,
Ye=Ye_found)
cons_errors = np.array([
RelDiff(Cons_target["D"], Cons_found["D"]),
RelDiff(Cons_target["DYe"], Cons_found["DYe"]),
RelDiff(Cons_target["tau"], Cons_found["tau"]),
RelDiff(Cons_target["S2"], Cons_found["S2"])
])
errors = np.array([
2 * (rho_found - rho_target) / (rho_found + rho_target),
2 * (T_found - T_target) / (T_found + T_target),
2 * (v1_found - v1_target) / (v1_found + v1_target),
2 * (v2_found - v2_target) / (v2_found + v2_target),
2 * (v3_found - v3_target) / (v3_found + v3_target),
2 * (press_found - press_target) / (press_found + press_target),
2 * (eps_found - eps_target) / (eps_found + eps_target)
])
prim_err = np.sqrt(np.sum(errors**2) / len(errors))
con_err = np.max(np.abs(cons_errors))
if printTable:
print("Primitive Vars")
print("var target found relative_error")
print("rho: " + table_string(rho_target) + table_string(rho_found) +
table_string(
np.abs(2 * (rho_found - rho_target) /
(rho_found + rho_target))))
print("T: " + table_string(T_target) + table_string(T_found) +
table_string(
np.abs(2 * (T_found - T_target) / (T_found + T_target))))
print("v1: " + table_string(v1_target) + table_string(v1_found) +
table_string(
np.abs(2 * (v1_found - v1_target) / (v1_found + v1_target))))
print("v2: " + table_string(v2_target) + table_string(v2_found) +
table_string(
np.abs(2 * (v2_found - v2_target) / (v2_found + v2_target))))
print("v3: " + table_string(v3_target) + table_string(v3_found) +
table_string(
np.abs(2 * (v3_found - v3_target) / (v3_found + v3_target))))
print("press: " + table_string(press_target) +
table_string(press_found) + table_string(
np.abs(2 * (press_found - press_target) /
(press_found + press_target))))
print("eps: " + table_string(eps_target) + table_string(eps_found) +
table_string(
np.abs(2 * (eps_found - eps_target) /
(eps_found + eps_target))))
print("")
print("Conservative Vars")
print("var target found relative_error")
print("D: " + table_string(Cons_target["D"]) +
table_string(Cons_found["D"]) + table_string(cons_errors[0]))
print("DYe: " + table_string(Cons_target["DYe"]) +
table_string(Cons_found["DYe"]) + table_string(cons_errors[1]))
print("tau: " + table_string(Cons_target["tau"]) +
table_string(Cons_found["tau"]) + table_string(cons_errors[2]))
print("S2: " + table_string(Cons_target["S2"]) +
table_string(Cons_found["S2"]) + table_string(cons_errors[3]))
return prim_err, con_err
def Bisection_TFromEpsRho(eps_target,rho,Ye,max_it=100,rel_diff=1e-14,abs_diff=1e-15,T_guess_low=None,T_guess_high=None):
if T_guess_low==None:
T_guess_low = 10**log_T_array[0]
if T_guess_high==None:
T_guess_high = 10**log_T_array[-1]
a0 = T_guess_low
b0 = T_guess_high
fa0 = Root(eps_target,a0,rho,Ye)
fb0 = Root(eps_target,b0,rho,Ye)
epsilon_0 = np.abs(a0-b0)
epsilon_target = 0.5*(a0+b0)*rel_diff
n_its = int((np.log(epsilon_0) - np.log(epsilon_target))/np.log(2))
it = 0
max_its = int(np.max([max_it,n_its]))
done = False
if fa0==0:
T_result = a0
success=True
done = True
elif fb0==0:
T_result = b0
success=True
done = True
eps_a0 = EOS_epsFromPrim(a0,rho,Ye)
eps_b0 = EOS_epsFromPrim(b0,rho,Ye)
if eps_target<eps_a0:
T_result = a0
success = False
done = True
if eps_target>eps_b0:
T_result = b0
success = False
done = True
if fa0*fb0>0.0 and done==False:
print("eps_target",eps_target)
print("rho",rho)
print("Ye",Ye)
print("a0",a0)
print("fa0",fa0)
print("eps(a0)",EOS_epsFromPrim(a0,rho,Ye))
print("b0",b0)
print("fb0",fb0)
print("eps(b0)",EOS_epsFromPrim(b0,rho,Ye))
raise ValueError("fa0, fb0 have same sign!")
ak = a0
bk = b0
fak = fa0
fbk = fb0
while done==False:
m = (ak + bk)/2.0
fm = Root(eps_target,m,rho,Ye)
### update ###
if fm==0:
T_result = m
success=True
done = True
elif fm*fak<0:
bk = m
fbk = fm
else:
ak = m
fak = fm
if np.abs(fak/ak)<rel_diff:
T_result = ak
success=True
done = True
if np.abs(fbk/bk)<rel_diff:
T_result = bk
success=True
done = True
it += 1
if it>=max_its:
if np.abs(fak)<np.abs(fbk):
T_result = ak
else:
T_result = bk
done = True
success=False
return T_result, success, it
def Root(eps,T,rho,Ye):
return eps - EOS_epsFromPrim(T,rho,Ye)
test_T_array = 10**(np.linspace(log_T_array[0],log_T_array[-1],num=T_samples+2)[1:-1])
test_rho_array = 10**(np.linspace((log_rho_array[log_rho_array>-12])[0],(log_rho_array[log_rho_array<-2.5])[-1],num=rho_samples+2)[1:-1])
test_Ye_array = np.linspace(Ye_array[0],Ye_array[-1],num=Ye_samples+2)[1:-1]
iterationsForConvergence = np.zeros((len(test_T_array),len(test_rho_array),len(test_Ye_array)))
errors = np.zeros((len(test_T_array),len(test_rho_array),len(test_Ye_array)))
for T_test_idx in range(len(test_T_array)):
print(T_test_idx)
T_test = test_T_array[T_test_idx]
for rho_test_idx in range(len(test_rho_array)):
rho_test = test_rho_array[rho_test_idx]
for Ye_test_idx in range(len(test_Ye_array)):
Ye_test = test_Ye_array[Ye_test_idx]
eps_test = EOS_epsFromPrim(T_test,rho_test,Ye_test)
T_conv, its_taken = TInversionDriverBis(eps_test,rho_test,Ye_test)
errors[T_test_idx,rho_test_idx,Ye_test_idx] = 0.5*(T_test-T_conv)/(T_test+T_conv)
if its_taken == -1:
failed.append(np.array([T_test_idx,rho_test_idx,Ye_test_idx]))
its_taken = 1
iterationsForConvergence[T_test_idx,rho_test_idx,Ye_test_idx] = its_taken
print(np.max(errors))
iterationsForConvergence = np.log10(iterationsForConvergence)
it_min = 0
it_max = np.max(iterationsForConvergence)
plot = True
def GetInitialGuess(rho=None, velocity=[], T=None, Ye=None):
targets = Targets()
if rho:
targets.rho = rho
else:
### Density ###
log_rho_min = -11
log_rho_max = -3
alpha = 2
beta = 7
log_rho = log_rho_min + ((1 - betavariate(alpha, beta)) *
(log_rho_max - log_rho_min))
targets.rho = 10**log_rho
if velocity != []:
targets.v1 = velocity[0]
targets.v2 = velocity[1]
targets.v3 = velocity[2]
else:
### Velocity ###
alpha = 2
beta = 3
speed = 0.5 * betavariate(alpha, beta)
theta = 2 * np.pi * random()
phi = np.arccos(-1.0 + 2 * random())
targets.v1 = speed * np.cos(theta) * np.sin(phi)
targets.v2 = speed * np.sin(theta) * np.sin(phi)
targets.v3 = speed * np.cos(phi)
if T:
targets.T = T
else:
### Temperature ###
log_T_min = log_T_array[0] + 0.5
log_T_max = log_T_array[-1] - 0.5
alpha = 2
beta = 7
log_T = log_T_min + (betavariate(alpha, beta) *
(log_T_max - log_T_min))
targets.T = 10**log_T
if Ye:
targets.Ye = Ye
else:
### Ye ###
Ye_min = Ye_array[2]
Ye_max = Ye_array[-3]
alpha = 2
beta = 11
targets.Ye = Ye_min + (betavariate(alpha, beta) * (Ye_max - Ye_min))
### Primitive ###
targets.vsq = np.linalg.norm([targets.v1, targets.v2, targets.v3])**2
targets.W = 1 / (np.sqrt(1 - targets.vsq))
targets.press = EOS_pressFromPrim(targets.T, targets.rho, targets.Ye)
targets.eps = EOS_epsFromPrim(targets.T, targets.rho, targets.Ye)
targets.h = 1 + targets.eps + targets.press / targets.rho
targets.z = targets.h * targets.rho * (targets.W**2)
##### Conserved #####
D = targets.rho * targets.W
S_1 = (targets.rho * targets.h) * (targets.W**2) * targets.v1
S_2 = (targets.rho * targets.h) * (targets.W**2) * targets.v2
S_3 = (targets.rho * targets.h) * (targets.W**2) * targets.v3
tau = (targets.rho * targets.h) * (targets.W**2) - targets.press - D
DYe = D * targets.Ye
S2 = ((targets.rho * targets.h)**2) * (targets.W**4) * (targets.vsq)
Cons_target = {
"D": D,
"S_1": S_1,
"S_2": S_2,
"S_3": S_3,
"tau": tau,
"DYe": DYe,
"S2": S2
}
return targets, Cons_target
return guesses
##### Primitives #####
rho_target = 2.8358299540575783e-09
v1_target = 0.1
v2_target = -0.2
v3_target = 0.15
Ye_target = 0.315
T_target = 4.166582513489608
vsq_target = np.linalg.norm([v1_target, v2_target, v3_target])**2
W_target = 1 / (np.sqrt(1 - vsq_target))
press_target = EOS_pressFromPrim(T_target, rho_target, Ye_target)
eps_target = EOS_epsFromPrim(T_target, rho_target, Ye_target)
h_target = 1 + eps_target + press_target / rho_target
##### Conserved #####
D = rho_target * W_target
S_1 = (rho_target * h_target) * (W_target**2) * v1_target
S_2 = (rho_target * h_target) * (W_target**2) * v2_target
S_3 = (rho_target * h_target) * (W_target**2) * v3_target
tau = (rho_target * h_target) * (W_target**2) - press_target - D
DYe = D * Ye_target
S2 = ((rho_target * h_target)**2) * (W_target**4) * (v2_target)
Cons_target = {
"D": D,
"S_1": S_1,
"S_2": S_2,