def getMoments(polyOrder, pre, numInterp):
d = postgkyl.GData("%s-sod-shock_neut_M0_1.bp" % pre)
dg = postgkyl.GInterpModal(d, polyOrder, "ms", numInterp=numInterp)
X, m0 = dg.interpolate()
d = postgkyl.GData("%s-sod-shock_neut_M1i_1.bp" % pre)
dg = postgkyl.GInterpModal(d, polyOrder, "ms", numInterp=numInterp)
X, m1i = dg.interpolate()
d = postgkyl.GData("%s-sod-shock_neut_M2_1.bp" % pre)
dg = postgkyl.GInterpModal(d, polyOrder, "ms", numInterp=numInterp)
X, m2 = dg.interpolate()
d = postgkyl.GData("%s-sod-shock_neut_M3i_1.bp" % pre)
dg = postgkyl.GInterpModal(d, polyOrder, "ms", numInterp=numInterp)
X, m3i = dg.interpolate()
u = m1i / m0 # Velocity.
nvt2 = m2 - m0 * u**2 # Pressure (density*temperature).
q = m3i - (3 * u * m2 - 3 * u**2 * m1i + u**3 * m0
) # Plasma-frame heat-flux.
Xn = X[0]
dx = Xn[1] - Xn[0]
# Cell-center coordinates.
Xc = linspace(Xn[0] + 0.5 * dx, Xn[-1] - 0.5 * dx, Xn.shape[0] - 1)
return Xc, m0, u, nvt2, q
def getMoments(polyOrder, pre, numInterp):
d = postgkyl.GData("%s-sod-shock_neut_M0_1.bp" % pre)
dg = postgkyl.GInterpModal(d, polyOrder, "ms", numInterp=numInterp)
X, m0 = dg.interpolate()
d = postgkyl.GData("%s-sod-shock_neut_M1i_1.bp" % pre)
dg = postgkyl.GInterpModal(d, polyOrder, "ms", numInterp=numInterp)
X, m1i = dg.interpolate()
d = postgkyl.GData("%s-sod-shock_neut_M2_1.bp" % pre)
dg = postgkyl.GInterpModal(d, polyOrder, "ms", numInterp=numInterp)
X, m2 = dg.interpolate()
d = postgkyl.GData("%s-sod-shock_neut_M3i_1.bp" % pre)
dg = postgkyl.GInterpModal(d, polyOrder, "ms", numInterp=numInterp)
X, m3i = dg.interpolate()
u = m1i/m0 # velocity
nvt2 = m2 - m0*u**2 # ptcl internal energy
q = m3i - (3*u*m2 - 3*u**2*m1i + u**3*m0) # heat-flux
Xn = X[0]; dx = Xn[1]-Xn[0]
# cell-center coordinates
Xc = linspace(Xn[0]+0.5*dx, Xn[-1]-0.5*dx, Xn.shape[0]-1)
return Xc, m0, u, nvt2, q
def getGrid(dataFile, p, basisType, **opKey):
pgData = pg.GData(dataFile) #.Read data with pgkyl.
pgInterp = pg.GInterpModal(pgData, p, basisType) #.Interpolate data.
xNodal, dataInterp = pgInterp.interpolate()
dimOut = np.shape(xNodal)[0] #.Number of dimensions in data.
#.If desired, output cell center values of grid coordinates instead of nodal coordinates.
if 'location' in opKey:
if opKey['location'] == 'center':
xOut = [[] for i in range(dimOut)]
for i in range(dimOut):
nNodes = np.shape(xNodal[i])[0]
xOut[i] = np.zeros(nNodes - 1)
xOut[i] = np.multiply(
0.5, xNodal[i][0:nNodes - 1] + xNodal[i][1:nNodes])
else:
xOut = xNodal
else:
xOut = xNodal
nxOut = np.zeros(dimOut, dtype='int')
lxOut = np.zeros(dimOut, dtype='double')
dxOut = np.zeros(dimOut, dtype='double')
for i in range(dimOut):
nxOut[i] = np.size(xOut[i])
lxOut[i] = xOut[i][-1] - xOut[i][0]
dxOut[i] = xOut[i][1] - xOut[i][0]
return xOut, dimOut, nxOut, lxOut, dxOut
def getDist(pre, fr):
d = postgkyl.GData("%s-bi-maxwellian-relax_neut_%d.bp" % (pre, fr))
dg = postgkyl.GInterpModal(d, 2, "ms")
XX, fv = dg.interpolate()
X, V = meshgrid(XX[1], XX[2])
return X, V, fv
def getInterpData(dataFile, p, basisType, **opKey):
pgData = pg.GData(dataFile) #.Read data with pgkyl.
pgInterp = pg.GInterpModal(pgData, p, basisType) #.Interpolate data.
if 'comp' in opKey:
xOut, dataOut = pgInterp.interpolate(opKey['comp'])
else:
xOut, dataOut = pgInterp.interpolate()
return dataOut
def getEntropy(polyOrder, pre):
svals = zeros((100, ), float)
for i in range(0, 100):
d = postgkyl.GData("%s-relax_neut_%d.bp" % (pre, i))
dg = postgkyl.GInterpModal(d, polyOrder, "ms")
XX, fv = dg.interpolate()
svals[i] = calcEntropy(XX[0], XX[1], fv)
return svals
def calcDivError(pre,p,numInterp,fr):
# Inputs:
# pre - prefix for file name.
# p - polynomial order (used for assisting in distinguishing between different prefixes).
# numInterp - number of points on which to interpolate DG basis functions.
# fr - frame number to read-in.
# Outputs:
# Xc - cell center coordinates for interpolated fields.
# E_dx - x-derivative of the x-electric field.
# rho_c - charge density divide by permittivity of free space (epsilon0).
# Read in electric field data of specified frame.
d = postgkyl.GData("%s-conservation-test-%s_field_%d.bp" % (pre,p,fr))
dg = postgkyl.GInterpModal(d, 2, "ms", numInterp)
# Interpolate the zeroth component (Ex).
X, Ex = dg.interpolate(0)
# Read in and interpolate electron number density of specified frame.
d = postgkyl.GData("%s-conservation-test-%s_elc_M0_%d.bp" % (pre,p,fr))
dg = postgkyl.GInterpModal(d, 2, "ms", numInterp)
X, n_e = dg.interpolate()
# Read in and interpolate proton number density of specified frame.
d = postgkyl.GData("%s-conservation-test-%s_ion_M0_%d.bp" % (pre,p,fr))
dg = postgkyl.GInterpModal(d, 2, "ms", numInterp)
X, n_i = dg.interpolate()
# Dividing charge density by epsilon0 here for comparison to divergence of the electric field.
rho_c = (elcCharge*n_e + ionCharge*n_i)/epsilon0
Xn = X[0]; dx = Xn[1]-Xn[0]
# Cell-center coordinates.
Xc = linspace(Xn[0]+0.5*dx, Xn[-1]-0.5*dx, Xn.shape[0]-1)
# Compute derivative of Ex in x.
E_dx = gradient(Ex, dx , edge_order=2, axis=0)
return Xc, E_dx[:,0], rho_c[:,0]
cnt = Counter()
def getXv(Xc, Vc):
dx = (Xc[0, -1] - Xc[0, 0]) / (Xc.shape[1] - 1)
dv = (Vc[-1, 0] - Vc[0, 0]) / (Vc.shape[0] - 1)
X1 = linspace(Xc[0, 0] + 0.5 * dx, Xc[0, -1] - 0.5 * dx, Xc.shape[1] - 1)
V1 = linspace(Vc[0, 0] + 0.5 * dv, Vc[-1, 0] - 0.5 * dv, Vc.shape[0] - 1)
return X1, V1
# density
d = postgkyl.GData("m11-2x3v-ser-mom_numDensity.bp")
dg1Num = postgkyl.GInterpModal(d, 1, "ms")
Xc, num = dg1Num.interpolate(0)
Xhr = linspace(Xc[0][0], Xc[0][-1], 200) # for plotting
dx = Xc[0][1] - Xc[0][0]
Xc0 = linspace(Xc[0][0] + 0.5 * dx, Xc[0][-1] - 0.5 * dx, Xc[0].shape[0] - 1)
n = sin(2 * pi * Xhr)
ux = 0.1 * cos(2 * pi * Xhr)
uy = 0.2 * sin(2 * pi * Xhr)
uz = 0.1 * cos(2 * pi * Xhr)
Txx = 0.75 + 0.25 * cos(2 * pi * Xhr)
Tyy = 0.75 + 0.25 * sin(2 * pi * Xhr)
Tzz = 0.75 + 0.1 * sin(2 * pi * Xhr)
Txy = 0.5 + 0.1 * sin(2 * pi * Xhr)
Txz = 0.25 + 0.1 * sin(2 * pi * Xhr)
cnt = Counter()
def getXv(Xc, Vc):
dx = (Xc[0, -1] - Xc[0, 0]) / (Xc.shape[1] - 1)
dv = (Vc[-1, 0] - Vc[0, 0]) / (Vc.shape[0] - 1)
X1 = linspace(Xc[0, 0] + 0.5 * dx, Xc[0, -1] - 0.5 * dx, Xc.shape[1] - 1)
V1 = linspace(Vc[0, 0] + 0.5 * dv, Vc[-1, 0] - 0.5 * dv, Vc.shape[0] - 1)
return X1, V1
# density
d = postgkyl.GData("x10-1x3v-max-mom_numDensity.bp")
dg1Num = postgkyl.GInterpModal(d, 4, "mo")
Xc, num = dg1Num.interpolate(0)
Xhr = linspace(Xc[0][0], Xc[0][-1], 200) # for plotting
n = sin(2 * pi * Xhr)
ux = 0.1 * cos(2 * pi * Xhr)
uy = 0.2 * sin(2 * pi * Xhr)
uz = 0.1 * cos(2 * pi * Xhr)
Txx = 0.75 + 0.25 * cos(2 * pi * Xhr)
Tyy = 0.75 + 0.25 * sin(2 * pi * Xhr)
Tzz = 0.75 + 0.1 * sin(2 * pi * Xhr)
Txy = 0.5 + 0.1 * sin(2 * pi * Xhr)
Txz = 0.25 + 0.1 * sin(2 * pi * Xhr)
Tyz = 0.125 + 0.1 * sin(2 * pi * Xhr)
from pylab import *
import postgkyl
style.use('../code/postgkyl.mplstyle')
# lineouts
d = postgkyl.GData("m10-2d-adv-dg_distf_0.bp")
dg = postgkyl.GInterpModal(d, 1, 'ms')
X, f0 = dg.interpolate(0)
d = postgkyl.GData("m10-2d-adv-dg_distf_1.bp")
dg = postgkyl.GInterpModal(d, 1, 'ms')
X, mf1 = dg.interpolate(0)
d = postgkyl.GData("../s10/s10-2d-adv-dg_distf_1.bp")
dg = postgkyl.GInterpModal(d, 1, 'ms')
X, sf1 = dg.interpolate(0)
figure(1)
ny = f0.shape[1]
plot(X[0], f0[:, ny / 2], 'k', label='EX')
plot(X[0], mf1[:, ny / 2], label='AL')
plot(X[0], sf1[:, ny / 2], label='NL')
xlabel('X')
ylabel('f(X)')
legend(loc='best')
grid()
savefig('s10-m10-cmp.png', dpi=150)
show()
from pylab import *
import postgkyl
style.use("postgkyl.mplstyle")
def getXc(Xn):
dx = Xn[1]-Xn[0]
Xc = linspace(Xn[0]+0.5*dx, Xn[-1]-0.5*dx, Xn.shape[0]-1)
return Xc
# Density and flow.
d = postgkyl.GData("n2/n2-sonic-sod-shock_neut_M0_1.bp")
dg = postgkyl.GInterpModal(d, 2, "ms")
X, m0 = dg.interpolate()
d = postgkyl.GData("n2/n2-sonic-sod-shock_neut_M1i_1.bp")
dg = postgkyl.GInterpModal(d, 2, "ms")
X, m1i = dg.interpolate()
Xn = X[0]; dx = Xn[1]-Xn[0]
# Cell-center configuration space coordinates.
Xc = linspace(Xn[0]+0.5*dx, Xn[-1]-0.5*dx, Xn.shape[0]-1)
# Distribution function.
d = postgkyl.GData("n2/n2-sonic-sod-shock_neut_1.bp")
dg = postgkyl.GInterpModal(d, 2, "ms")
X, fv1 = dg.interpolate()
# Center velocity space coordinates and construct meshgrid
Xn = X[0]; dx = Xn[1]-Xn[0]
Xc = linspace(Xn[0]+0.5*dx, Xn[-1]-0.5*dx, Xn.shape[0]-1)
