def evalImplicit(self, i, cx_prev, hydro_prev, rad_prev, slopes_old, **kwargs):
# get local indices
Lm = getLocalIndex("L","-") # dof L,-
Lp = getLocalIndex("L","+") # dof L,+
Rm = getLocalIndex("R","-") # dof R,-
Rp = getLocalIndex("R","+") # dof R,+
# get left and right total cross sections
cxtL = cx_prev[i][0].sig_t
cxtR = cx_prev[i][1].sig_t
# compute left and right velocities
u = computeEdgeVelocities(i, hydro_prev[i], slopes_old)
# compute left and right radiation energies and fluxes
EL = rad_prev.E[i][0]
ER = rad_prev.E[i][1]
# return local Q values
Q_local = np.zeros(4)
Q_local[Lm] = 2.0*mu["-"]*cxtL*EL*u[0]
Q_local[Lp] = 2.0*mu["+"]*cxtL*EL*u[0]
Q_local[Rm] = 2.0*mu["-"]*cxtR*ER*u[1]
Q_local[Rp] = 2.0*mu["+"]*cxtR*ER*u[1]
return Q_local
def evalImplicit(self, i, cx_prev, hydro_prev, rad_prev, slopes_old, **kwargs):
# get local indices
Lm = getLocalIndex("L","-") # dof L,-
Lp = getLocalIndex("L","+") # dof L,+
Rm = getLocalIndex("R","-") # dof R,-
Rp = getLocalIndex("R","+") # dof R,+
# get left and right total cross sections
cxtL = cx_prev[i][0].sig_t
cxtR = cx_prev[i][1].sig_t
# compute left and right velocities
u = computeEdgeVelocities(i, hydro_prev[i], slopes_old)
# compute left and right radiation energies and fluxes
c = GC.SPD_OF_LGT
EL = rad_prev.E[i][0]
ER = rad_prev.E[i][1]
FL = rad_prev.F[i][0]
FR = rad_prev.F[i][1]
F0L = FL - 4.0/3.0*EL*u[0]
F0R = FR - 4.0/3.0*ER*u[1]
# return local Q values
Q_local = np.zeros(4)
Q_local[Lm] = -cxtL*u[0]/c*F0L*0.5 #0.5 because it is isotropic
Q_local[Lp] = -cxtL*u[0]/c*F0L*0.5
Q_local[Rm] = -cxtR*u[1]/c*F0R*0.5
Q_local[Rp] = -cxtR*u[1]/c*F0R*0.5
return Q_local
def evalImplicit(self, i, dt, cx_prev=None, hydro_prev=None, hydro_star=None,
E_slopes_star=None, QE=None, slopes_old=None, e_rad_prev=None, hydro_new=None, **kwargs):
# get coefficient corresponding to time-stepper
scales = {"CN":0.5, "BE":1., "BDF2":2./3.}
scale = scales[self.time_stepper]
# get constants
a = GC.RAD_CONSTANT
c = GC.SPD_OF_LGT
# get previous hydro state and specific heat
state_prev = hydro_prev[i]
state_star = hydro_star[i]
spec_heat = state_prev.spec_heat
#Compute edge velocities
u_new = computeEdgeVelocities(i, hydro_new[i], slopes_old)
#Compute left and right star energyes
E_star = [state_star.E() - 0.5*E_slopes_star[i],
state_star.E() + 0.5*E_slopes_star[i]]
# compute edge quantities, use newest density
rho = computeEdgeDensities(i, hydro_new[i], slopes_old)
T = computeEdgeTemperatures(spec_heat, e_rad_prev[i])
# compute Planckian term for each edge on element
planckian = [0.0,0.0]
for edge in range(2):
# get cross section
sig_a = cx_prev[i][edge].sig_a
# compute effective scattering fraction
nu = getNu(T[edge], sig_a, rho[edge], spec_heat, dt, scale)
QE_elem = QE[i][edge]
# compute Planckian
emission = (1.0 - nu)*sig_a*a*c*T[edge]**4
planckian[edge] = emission \
- nu/(scale*dt)*( rho[edge]*(e_rad_prev[i][edge] +0.5*u_new[edge]**2) \
- E_star[edge] ) \
+ nu*QE_elem/scale
# get local indices
Lm = getLocalIndex("L","-") # dof L,-
Lp = getLocalIndex("L","+") # dof L,+
Rm = getLocalIndex("R","-") # dof R,-
Rp = getLocalIndex("R","+") # dof R,+
# return local Q values
Q_local = np.zeros(4)
Q_local[Lm] = 0.5*planckian[0]
Q_local[Lp] = 0.5*planckian[0]
Q_local[Rm] = 0.5*planckian[1]
Q_local[Rp] = 0.5*planckian[1]
return Q_local
def evalRHSTerm(self, i, rad_old, rad_BC, time_step, **kwargs):
#If it is a time dependent boundary condition, make a copy and
#update to the old time
if time_step == "old":
psi_left, psi_right = rad_BC.getOldIncidentFluxes()
elif time_step == "older":
psi_left, psi_right = rad_BC.getOlderIncidentFluxes()
else:
raise IOError("Invalid call of evalRHSTerm BC time")
# get local indices
Lm = getLocalIndex("L","-") # dof L,-
Lp = getLocalIndex("L","+") # dof L,+
Rm = getLocalIndex("R","-") # dof R,-
Rp = getLocalIndex("R","+") # dof R,+
# psip_{i-1/2}
if i == 0: # left boundary
if rad_BC.bc_type == "periodic":
psip_Lface = rad_old.psip[self.mesh.n_elems-1][1] # psip_{N-1,R}
else:
psip_Lface = psi_left
else:
psip_Lface = rad_old.psip[i-1][1]
# psim_{i+1/2}
if i == self.mesh.n_elems - 1: # right boundary
if rad_BC.bc_type == "periodic":
psim_Rface = rad_old.psim[0][0] #psim_{0,L}
else:
psim_Rface = psi_right
else:
psim_Rface = rad_old.psim[i+1][0]
psim_L = rad_old.psim[i][0] # psim_{i,L}
psip_L = rad_old.psip[i][0] # psip_{i,L}
psim_R = rad_old.psim[i][1] # psim_{i,R}
psip_R = rad_old.psip[i][1] # psip_{i,R}
psim_Lface = psim_L # psim_{i-1/2}
psip_Rface = psip_R # psip_{i+1/2}
# compute cell center values
psim_i = 0.5*(psim_L + psim_R)
psip_i = 0.5*(psip_L + psip_R)
# mesh size divided by 2
h_over_2 = self.mesh.getElement(i).dx/2.0
# compute streaming source
Q_local = np.zeros(4)
Q_local[Lm] = -1.*mu["-"]*(psim_i - psim_Lface)/h_over_2
Q_local[Lp] = -1.*mu["+"]*(psip_i - psip_Lface)/h_over_2
Q_local[Rm] = -1.*mu["-"]*(psim_Rface - psim_i) /h_over_2
Q_local[Rp] = -1.*mu["+"]*(psip_Rface - psip_i) /h_over_2
return Q_local
def evalOld(self, i, hydro_old, cx_old, e_rad_old=None, **kwargs):
#use function forward to external function
planckian = evalPlanckianOld(i, hydro_old, cx_old, e_rad_old)
#Store the (isotropic) sources in correct index
Q = np.zeros(4)
Q[getLocalIndex("L","-")] = 0.5*planckian[0]
Q[getLocalIndex("L","+")] = 0.5*planckian[0]
Q[getLocalIndex("R","-")] = 0.5*planckian[1]
Q[getLocalIndex("R","+")] = 0.5*planckian[1]
return Q
def computeOldIntensityTerm(self, i, dt, rad_old):
# get local indices
Lm = getLocalIndex("L","-") # dof L,-
Lp = getLocalIndex("L","+") # dof L,+
Rm = getLocalIndex("R","-") # dof R,-
Rp = getLocalIndex("R","+") # dof R,+
# compute c*dt
c_dt = GC.SPD_OF_LGT * dt
# compute old intensity term
Q_local = np.zeros(4)
Q_local[Lm] = rad_old.psim[i][0] / c_dt
Q_local[Lp] = rad_old.psip[i][0] / c_dt
Q_local[Rm] = rad_old.psim[i][1] / c_dt
Q_local[Rp] = rad_old.psip[i][1] / c_dt
return Q_local
def evalOld(self, i, rad_old, cx_old, **kwargs):
# get local indices
Lm = getLocalIndex("L","-") # dof L,-
Lp = getLocalIndex("L","+") # dof L,+
Rm = getLocalIndex("R","-") # dof R,-
Rp = getLocalIndex("R","+") # dof R,+
# left and right cross sections
sig_t_L = cx_old[i][0].sig_t
sig_t_R = cx_old[i][1].sig_t
# compute reaction source
Q_local = np.zeros(4)
Q_local[Lm] = -1.*rad_old.psim[i][0] * sig_t_L
Q_local[Lp] = -1.*rad_old.psip[i][0] * sig_t_L
Q_local[Rm] = -1.*rad_old.psim[i][1] * sig_t_R
Q_local[Rp] = -1.*rad_old.psip[i][1] * sig_t_R
return Q_local
def evalOld(self, i, rad_old, cx_old, **kwargs):
# get local indices
Lm = getLocalIndex("L","-") # dof L,-
Lp = getLocalIndex("L","+") # dof L,+
Rm = getLocalIndex("R","-") # dof R,-
Rp = getLocalIndex("R","+") # dof R,+
# left and right scattering cross section
sig_s_L = cx_old[i][0].sig_s
sig_s_R = cx_old[i][1].sig_s
# left and right scalar fluxes
phi_L = rad_old.phi[i][0]
phi_R = rad_old.phi[i][1]
# compute scattering source
Q_local = np.zeros(4)
Q_local[Lm] = 0.5*phi_L*sig_s_L
Q_local[Rm] = 0.5*phi_R*sig_s_R
Q_local[Lp] = 0.5*phi_L*sig_s_L
Q_local[Rp] = 0.5*phi_R*sig_s_R
return Q_local