def dens(pres, eint):
"""
Given the pressure and the specific internal energy, return
the density
Parameters
----------
gamma : float
The ratio of specific heats
pres : float
The pressure
eint : float
The specific internal energy
Returns
-------
out : float
The density
"""
#dens = pres/(eint*(gamma - 1.0))
keyboard()
dens = PropsSI('DMASS', 'UMASS', eint,'P', pres, fluid)
dens = np.array(dens, order = 'F')
return dens
def getEnergyfromVolumeTemperature(self,v_in,T_in):
e0 = tools.getE_ideal(self.NASAcoeff,T_in,self.Rcst)
dAdT = self.getdAdT(T_in,self.A,self.G)
int_e = e0 + self.K1* ( self.A - T_in*dAdT )
keyboard()
return e0 + self.K1* ( self.A - T_in*dAdT )
def pres(dens, eint):
"""
Given the density and the specific internal energy, return the
pressure
Parameters
----------
gamma : float
The ratio of specific heats
dens : float
The density
eint : float
The specific internal energy
Returns
-------
out : float
The pressure
"""
#p = dens*eint*(gamma - 1.0)
# p = eint.copy()
# if (eint.ndim == 2):
# for i in range(np.shape(eint)[0]):
# for j in range(np.shape(eint)[1]):
# if dens[i][j] < 0.1 :
# p[i][j] = 0.0
# continue
# p[i][j] = PropsSI('P', 'UMASS', eint[i][j],'DMASS', dens[i][j], fluid)
# p = np.array(p, order = 'F')
# return p
# else:
# p = PropsSI('P', 'UMASS', eint,'DMASS', dens, fluid)
# p = np.array(p, order = 'F')
# return p
T = np.ones(np.shape(dens))
p = np.ones(np.shape(dens))
if (dens.ndim == 2):
for i in range(np.shape(dens)[0]):
# if dens[i].any() < 0.1:
# temp = dens[i]
# temp[temp < 0.1] = np.nan
# dens[i] = temp
# continue
eint[i] = tools.convertMassToMolar(eint[i], 28.0134)
T[i] = PREOS.getTfromEandRho(eint[i],dens[i])
p[i] = PREOS.getPfromTandRho(T[i], dens[i])
keyboard()
return p
else:
eint= tools.convertMassToMolar(eint, 28.0134)
T_in = PREOS.getTfromEandRho(eint,dens)
p = PREOS.getPfromTandRho(T, dens)
keyboard()
return p
def NewtonIterate_TemperaturefromEv(self,
e_target,
v_target,
T_in,
eps=1E-6,
omega=1.0):
# Newton Iteration to find temperature. Needs to pass energy in molar form!!!
T_n = T_in * np.ones(v_target.size)
self.setRealFluidThermodynamics(v_target, T_n)
e_n = self.getEnergyfromVolumeTemperature(v_target, T_n)
cv_n = self.getCv(v_target, T_n)
diff = (e_n - e_target)
prevdiff = diff.copy()
itera = 0
#Newton solver
range_convergence_complete = False
pointwise_converged = np.zeros(diff.shape)
flagged = False
# while not(range_convergence_complete):
# diff0 = max(abs(diff)) # old max diff
# prevdiff = diff.copy() # old diff array
# T_correction = omega * diff * e_target/cv_n; # corrections
# T_correction[np.where(pointwise_converged==True)] = 0. # filtering corrections
# T_n -= T_correction # MODIFY
# keyboard()
# self.setRealFluidThermodynamics(v_target,T_n) # set new state
# e_n = self.getEnergyfromVolumeTemperature(v_target,T_n) # evaluate new energy
# cv_n = self.getCv(v_target,T_n) # new Cv
# diff = (e_n - e_target)/e_target # new difference
# diff1 = max(abs(diff)) # new max diff
# if (diff1 > diff0):
# if (pointwise_converged[0]) and (pointwise_converged[-1]): # if ghost cells have converged (for continuity)
# break;
# elif itera > 10: # Taking too long AND ends not converged yet
# print "Taking too long"
# flagged = True
# break;
# # elif np.mean(prevdiff) < np.mean(diff): # average diverging
# # flagged = True
# # print "Average diverging failed"
# # break;
# pointwise_converged = (abs(diff)<eps)
# range_convergence_complete = not(False in pointwise_converged)
# pointwise_converged = np.array(pointwise_converged)
# itera+=1
while (max(abs(diff) > 1.0E-4)):
dpdt = self.getdPdT(v_target, T_n)
T_n = T_n - (diff / dpdt)
print T_n
self.setRealFluidThermodynamics(v_target, T_n)
e_n = self.getEnergyfromVolumeTemperature(v_target, T_n)
diff = e_n - e_target
keyboard()
return T_n
def rhoe(dens, pres):
"""
Given the pressure, return (rho * e)
Parameters
----------
gamma : float
The ratio of specific heats
pres : float
The pressure
Returns
-------
out : float
The internal energy density, rho e
"""
#rhoe = pres/(gamma - 1.0)
#eint = pres.copy()
# if (eint.ndim == 2):
# for i in range(np.shape(pres)[0]):
# for j in range(np.shape(pres)[1]):
# if dens[i][j] < 0.1 :
# eint[i][j] = 0.0
# continue
# eint[i][j] = PropsSI('UMASS', 'P', pres[i][j],'DMASS', dens[i][j], fluid)
# rhoe = np.array(dens*eint, order = 'F')
# return rhoe
# else:
# eint = PropsSI('P', 'UMASS', eint,'DMASS', dens, fluid)
# rhoe = np.array(dens*eint, order = 'F')
# return rhoe
MW = 28.0134
T = np.ones(np.shape(dens))
eint = np.ones(np.shape(dens))
if (dens.ndim == 2):
for i in range(np.shape(dens)[0]):
# if dens[i].any() < 0.1:
# temp = dens[i]
# temp[temp < 0.1] = np.nan
# dens[i] = temp
# continue
T[i] = PREOS.getTfromPandRho(pres[i], dens[i])
#T[i] = PropsSI('T', 'P', pres[i], 'DMASS', dens[i], 'Nitrogen')
eint[i] = PREOS.getEnergyfromTandRho(T[i], dens[i])
eint[i] = tools.convertMolarToMass(eint[i], MW) #J/Kg
keyboard()
return dens*eint
else:
T = PREOS.getTfromPandRho(pres, dens)
#T = PropsSI('T', 'P', pres, 'DMASS', dens, 'Nitrogen')
eint = PREOS.getEnergyfromTandRho(T, dens)
eint = tools.convertMolarToMass(eint, MW)
keyboard()
return dens*eint
def derive_primitives(myd, varnames):
"""
derive desired primitive variables from conserved state
"""
# get the variables we need
dens = myd.get_var("density")
xmom = myd.get_var("x-momentum")
ymom = myd.get_var("y-momentum")
ener = myd.get_var("energy")
derived_vars = []
u = xmom / dens
v = ymom / dens
e = (ener - 0.5 * dens * (u * u + v * v)) / dens
gamma = myd.get_aux("gamma")
p = eos.pres(dens, e)
# to import the class attributes
p = p * dens / dens
if isinstance(varnames, str):
wanted = [varnames]
else:
wanted = list(varnames)
for var in wanted:
if var == "velocity":
derived_vars.append(u)
derived_vars.append(v)
elif var in ["e", "eint"]:
keyboard()
derived_vars.append(e)
elif var in ["p", "pressure"]:
derived_vars.append(p)
elif var == "primitive":
derived_vars.append(dens)
derived_vars.append(u)
derived_vars.append(v)
derived_vars.append(p)
elif var == "soundspeed":
derived_vars.append(eos.sound(p, dens))
if len(derived_vars) > 1:
return derived_vars
else:
return derived_vars[0]
def book_event(account, sport, event, checkin, checkout):
booking: Booking = None
for b in event.bookings:
if b.check_in_time <= checkin and b.check_out_time >= checkout and b.tmember_sport_id is None:
booking = b
break
booking.tmember_owner_id = account.id
booking.tmember_sport_id = sport.id
booking.booked_date = datetime.datetime.now()
keyboard()
event.save()
def training_step(self, X_batch, X_boundary_batch, Y_batch, alpha, ba):
with tf.GradientTape(persistent=True) as tape:
Ypred = self.output(X_batch, X_boundary_batch)
keyboard()
aux = [
tf.reduce_mean(tf.square(Ypred[i] - Y_batch[:, i]))
for i in range(len(Ypred))
]
loss_data = tf.add_n(aux)
loss = loss_data
gradients_data = tape.gradient(
loss_data,
self.model.trainable_variables,
unconnected_gradients=tf.UnconnectedGradients.ZERO)
del tape
gradients = [x for x in gradients_data]
self.optimizer.apply_gradients(
zip(gradients, self.model.trainable_variables))
return loss_data
def getH_ideal(coef, T, RoM):
# mpi_rank = MPI.COMM_WORLD.Get_rank()
# print "\n ###### ############## ############### \n"
# print "\n I am mpi_rank = " + repr(mpi_rank)
# print "\n ###### coef.shape" + repr(coef.shape)
#if (True in np.isnan(T)):
#os._exit("NAN found in temperature in processor " + repr(mpi_rank))
if not (len(coef.shape) == 2):
keyboard()
coef = coef[0]
H_ideal = T * RoM * (coef[0] + coef[1] * T / 2.0 +
coef[2] * T**2 / 3.0 + coef[3] * T**3 / 4.0 +
coef[4] * T**4 / 5.0 + coef[5] / T)
return H_ideal
H_ideal = T * RoM * (coef[:, 0] + coef[:, 1] * T / 2.0 +
coef[:, 2] * T**2 / 3.0 + coef[:, 3] * T**3 / 4.0 +
coef[:, 4] * T**4 / 5.0 + coef[:, 5] / T)
return H_ideal
# Cantera Plug Flow Reactor Code
# Written by: Rufat Kulakhmetov
import cantera as ct
import numpy as np
import math
import csv
import copy
import os.path
from pdb import set_trace as keyboard
from momic_class import *
SootWSR = Soot('./Mechanisms/R2highT.cti')
SootWSR.initialize(6, 0, 0)
SootWSR.WSR.set_moments(np.exp([10, 11, 12, 13, 14, 15]))
SootWSR.WSR.set_inlet_Moments([0, 0, 0, 0, 0, 0])
SootWSR.WSR.set_reactor_properties(vol=np.pi * (1.17**2 / 4) * 9.2 *
(.0254)**3)
SootWSR.WSR.set_inlet_gas(300, 101325, 'POSF5433:1 O2:1', .06)
SootWSR.WSR.set_outlet('PC', 500 * 101325 / 14.7)
SootWSR.WSR.solve(1e-5, 1, convergence_criteria=1e-3)
# Solution is Stored in SootWSR.WSR.sol
Sol = SootWSR.WSR.Sol
keyboard()
def init_data(my_data, rp):
""" initialize the shu-osher problem """
msg.bold("initializing the sod problem...")
# make sure that we are passed a valid patch object
if not isinstance(my_data, patch.CellCenterData2d):
print("ERROR: patch invalid in shu_osher.py")
print(my_data.__class__)
sys.exit()
# get the shu_osher parameters
dens_left = rp.get_param("shu_osher.dens_left")
u_left = rp.get_param("shu_osher.u_left")
u_right = rp.get_param("shu_osher.u_right")
p_left = rp.get_param("shu_osher.p_left")
p_right = rp.get_param("shu_osher.p_right")
# get the density, momenta, and energy as separate variables
dens = my_data.get_var("density")
xmom = my_data.get_var("x-momentum")
ymom = my_data.get_var("y-momentum")
ener = my_data.get_var("energy")
# initialize the components, remember, that ener here is rho*eint
# + 0.5*rho*v**2, where eint is the specific internal energy
# (erg/g)
xmin = rp.get_param("mesh.xmin")
xmax = rp.get_param("mesh.xmax")
ymin = rp.get_param("mesh.ymin")
ymax = rp.get_param("mesh.ymax")
gamma = rp.get_param("eos.gamma")
direction = rp.get_param("shu_osher.direction")
#xctr = 0.5*(xmin + xmax)
xctr = -4.0
yctr = 0.5 * (ymin + ymax)
myg = my_data.grid
if direction == "x":
# left
idxl = myg.x2d <= xctr
dens[idxl] = dens_left
xmom[idxl] = dens_left * u_left
ymom[idxl] = 0.0
ener[idxl] = eos.rhoe(dens[idxl], p_left *
np.ones(np.shape(dens[idxl]))) #/ dens[idxl]
#ener[idxl] = p_left/(gamma - 1.0) + 0.5*xmom[idxl]*u_left
# right
idxr = myg.x2d > xctr
xdat = idxr[:, 0]
xall = myg.x2d[:, 0]
rhocrit = dens_left / 3.857
for i in range(xdat.shape[0]):
if idxr[i].all() == True:
dens[i] = (1.0 +
0.2 * np.sin(5.0 * xall[i])) * rhocrit * np.ones(18)
xmom[i] = (1.0 + 0.2 * np.sin(5.0 * xall[i])
) * rhocrit * np.ones(18) * u_right
ymom[i] = np.ones(18) * 0.0
ener[i] = eos.rhoe((1.0 + 0.2 * np.sin(5.0 * xall[i])) *
rhocrit * np.ones(18),
p_right * np.ones(18))
keyboard()
#dens[idxr] = 1.0 + 0.2*np.sin(5.0*xall[xdat])
#xmom[idxr] = dens_right*u_right
#ymom[idxr] = 0.0
#ener[idxr] = eos.rhoe(dens[idxr], p_right*np.ones(np.shape(dens[idxr]))) #/ dens[idxr]
#ener[idxr] = p_right/(gamma - 1.0) + 0.5*xmom[idxr]*u_right
else:
# bottom
idxb = myg.y2d <= yctr
dens[idxb] = dens_left
xmom[idxb] = 0.0
ymom[idxb] = dens_left * u_left
ener[idxb] = eos.rhoe(dens[idxb], p_left *
np.ones(np.shape(dens[idxb]))) #/ dens[idxb]
#ener[idxb] = p_left/(gamma - 1.0) + 0.5*ymom[idxb]*u_left
# top
idxt = myg.y2d > yctr
dens[idxt] = dens_right
xmom[idxt] = 0.0
ymom[idxt] = dens_right * u_right
ener[idxt] = eos.rhoe(dens[idxt],
p_right *
np.ones(np.shape(dens[idxt]))) #/ dens[idxt]
def init_data(my_data, rp):
""" initialize the Kelvin-Helmholtz problem """
msg.bold("initializing the sedov problem...")
# make sure that we are passed a valid patch object
if not isinstance(my_data, patch.CellCenterData2d):
print(my_data.__class__)
msg.fail("ERROR: patch invalid in sedov.py")
# get the density, momenta, and energy as separate variables
dens = my_data.get_var("density")
xmom = my_data.get_var("x-momentum")
ymom = my_data.get_var("y-momentum")
ener = my_data.get_var("energy")
# initialize the components, remember, that ener here is rho*eint
# + 0.5*rho*v**2, where eint is the specific internal energy
# (erg/g)
dens[:, :] = 1.0
xmom[:, :] = 0.0
ymom[:, :] = 0.0
rho_1 = rp.get_param("kh.rho_1")
v_1 = rp.get_param("kh.v_1")
rho_2 = rp.get_param("kh.rho_2")
v_2 = rp.get_param("kh.v_2")
gamma = rp.get_param("eos.gamma")
xmin = rp.get_param("mesh.xmin")
xmax = rp.get_param("mesh.xmax")
ymin = rp.get_param("mesh.ymin")
ymax = rp.get_param("mesh.ymax")
yctr = 0.5 * (ymin + ymax)
L_x = xmax - xmin
myg = my_data.grid
idx_l = myg.y2d < yctr + 0.01 * np.sin(10.0 * np.pi * myg.x2d / L_x)
idx_h = myg.y2d >= yctr + 0.01 * np.sin(10.0 * np.pi * myg.x2d / L_x)
# lower half
dens[idx_l] = rho_1
xmom[idx_l] = rho_1 * v_1
ymom[idx_l] = 0.0
# upper half
dens[idx_h] = rho_2
xmom[idx_h] = rho_2 * v_2
ymom[idx_h] = 0.0
#p = 1.0
p = 6.9E06 * np.ones(np.shape(dens))
#ener[:,:] = p/(gamma - 1.0) + 0.5*(xmom[:,:]**2 + ymom[:,:]**2)/dens[:,:]
ener[:, :] = eos.rhoe(
dens[:, :], p) + 0.5 * (xmom[:, :]**2 + ymom[:, :]**2) / dens[:, :]
keyboard()
def init_data(my_data, rp):
""" initialize the quadrant problem """
msg.bold("initializing the quadrant problem...")
# make sure that we are passed a valid patch object
if not isinstance(my_data, patch.CellCenterData2d):
print("ERROR: patch invalid in quad.py")
print(my_data.__class__)
sys.exit()
# get the density, momenta, and energy as separate variables
dens = my_data.get_var("density")
xmom = my_data.get_var("x-momentum")
ymom = my_data.get_var("y-momentum")
ener = my_data.get_var("energy")
# initialize the components, remember, that ener here is
# rho*eint + 0.5*rho*v**2, where eint is the specific
# internal energy (erg/g)
r1 = rp.get_param("quadrant.rho1")
u1 = rp.get_param("quadrant.u1")
v1 = rp.get_param("quadrant.v1")
p1 = rp.get_param("quadrant.p1")
r2 = rp.get_param("quadrant.rho2")
u2 = rp.get_param("quadrant.u2")
v2 = rp.get_param("quadrant.v2")
p2 = rp.get_param("quadrant.p2")
r3 = rp.get_param("quadrant.rho3")
u3 = rp.get_param("quadrant.u3")
v3 = rp.get_param("quadrant.v3")
p3 = rp.get_param("quadrant.p3")
r4 = rp.get_param("quadrant.rho4")
u4 = rp.get_param("quadrant.u4")
v4 = rp.get_param("quadrant.v4")
p4 = rp.get_param("quadrant.p4")
cx = rp.get_param("quadrant.cx")
cy = rp.get_param("quadrant.cy")
gamma = rp.get_param("eos.gamma")
# there is probably an easier way to do this, but for now, we
# will just do an explicit loop. Also, we really want to set
# the pressue and get the internal energy from that, and then
# compute the total energy (which is what we store). For now
# we will just fake this
myg = my_data.grid
iq1 = np.logical_and(myg.x2d >= cx, myg.y2d >= cy)
iq2 = np.logical_and(myg.x2d < cx, myg.y2d >= cy)
iq3 = np.logical_and(myg.x2d < cx, myg.y2d < cy)
iq4 = np.logical_and(myg.x2d >= cx, myg.y2d < cy)
# quadrant 1
dens[iq1] = r1
xmom[iq1] = r1*u1
ymom[iq1] = r1*v1
#ener[iq1] = eos.rhoe(p1*np.ones(np.shape(dens[iq1])), dens[iq1]) + 0.5*r1*(u1*u1 + v1*v1)
keyboard()
ener[iq1] = p1/(gamma - 1.0) + 0.5*r1*(u1*u1 + v1*v1)
# quadrant 2
dens[iq2] = r2
xmom[iq2] = r2*u2
ymom[iq2] = r2*v2
#ener[iq2] = eos.rhoe(p1*np.ones(np.shape(dens[iq2])), dens[iq2]) + 0.5*r2*(u2*u2 + v2*v2)
ener[iq2] = p2/(gamma - 1.0) + 0.5*r2*(u2*u2 + v2*v2)
# quadrant 3
dens[iq3] = r3
xmom[iq3] = r3*u3
ymom[iq3] = r3*v3
#ener[iq3] = eos.rhoe(p1*np.ones(np.shape(dens[iq3])), dens[iq3]) + 0.5*r3*(u3*u3 + v3*v3)
ener[iq3] = p3/(gamma - 1.0) + 0.5*r3*(u3*u3 + v3*v3)
# quadrant 4
dens[iq4] = r4
xmom[iq4] = r4*u4
ymom[iq4] = r4*v4
#ener[iq4] = eos.rhoe(p1*np.ones(np.shape(dens[iq4])), dens[iq4]) + 0.5*r4*(u4*u4 + v4*v4)
ener[iq4] = p4/(gamma - 1.0) + 0.5*r4*(u4*u4 + v4*v4)