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)