def model():
problems = ['test1', 'test2', 'test3', 'test4']
runs = [
'exact', 'CW', 'CW-ev', 'flash', 'flash-nochar', 'MC', 'MC-ev',
'MC-ppmT-I-ev', 'MC-ppmT-II-ev', 'MC-ppmT-III-ev'
]
for p in problems:
print "working on problem: ", p
# read in all the data, store in a dictionary
data = {}
for r in runs:
if r == "exact":
modelData = dataRead.getData("exact/%s.exact.128.out" % (p))
vars = dataObj()
vars.x = modelData[:, 1]
vars.rho = modelData[:, 2]
vars.u = modelData[:, 3]
vars.p = modelData[:, 4]
vars.T = modelData[:, 5]
data[r] = vars
elif r == "flash":
modelData = dataRead.getData("flash/%s/flash.par.%s.data" %
(p, p))
vars = dataObj()
vars.x = modelData[:, 0]
vars.rho = modelData[:, 1]
vars.T = modelData[:, 3]
vars.u = modelData[:, 4]
vars.p = modelData[:, 2]
data[r] = vars
elif r == "flash-nochar":
modelData = dataRead.getData(
"flash/%s/flash.par.%s.nocharlimit.data" % (p, p))
vars = dataObj()
vars.x = modelData[:, 0]
vars.rho = modelData[:, 1]
vars.T = modelData[:, 3]
vars.u = modelData[:, 4]
vars.p = modelData[:, 2]
data[r] = vars
else:
# find the last slice file with our pattern
files = []
for f in os.listdir(r):
if fnmatch.fnmatch(f, "%s*plt?????.slice" % (p)):
files.append(f)
files.sort()
dataFile = files[len(files) - 1]
modelData = dataRead.getData("%s/%s" % (r, dataFile))
vars = dataObj()
vars.x = modelData[:, 0]
vars.rho = modelData[:, 1]
vars.u = modelData[:, 2] / modelData[:, 1]
vars.p = modelData[:, 10]
vars.T = modelData[:, 6]
data[r] = vars
# done reading
print " "
print "problem: {}".format(p)
print "L2 norm"
print "{:^20s} {:^20s} {:^20s} {:^20s} {:^20s}".format(
"run", "rho", "u", "p", "T")
for r in runs:
e_rho = numpy.linalg.norm(data[r].rho - data["exact"].rho,
ord=2) / numpy.linalg.norm(
data["exact"].rho, ord=2)
e_u = numpy.linalg.norm(data[r].u - data["exact"].u,
ord=2) / numpy.linalg.norm(data["exact"].u,
ord=2)
e_p = numpy.linalg.norm(data[r].p - data["exact"].p,
ord=2) / numpy.linalg.norm(data["exact"].p,
ord=2)
e_T = numpy.linalg.norm(data[r].T - data["exact"].T,
ord=2) / numpy.linalg.norm(data["exact"].T,
ord=2)
print "{:20s} {:20.4f} {:20.4f} {:20.4f} {:20.4f}".format(
r, e_rho, e_u, e_p, e_T)
print " "
print "L-infty norm"
print "{:^20s} {:^20s} {:^20s} {:^20s} {:^20s}".format(
"run", "rho", "u", "p", "T")
for r in runs:
e_rho = numpy.max(
numpy.abs(data[r].rho - data["exact"].rho)) / numpy.max(
numpy.abs(data["exact"].rho))
e_u = numpy.max(
numpy.abs(data[r].u - data["exact"].u)) / numpy.max(
numpy.abs(data["exact"].u))
e_p = numpy.max(
numpy.abs(data[r].p - data["exact"].p)) / numpy.max(
numpy.abs(data["exact"].p))
e_T = numpy.max(
numpy.abs(data[r].T - data["exact"].T)) / numpy.max(
numpy.abs(data["exact"].T))
print "{:20s} {:20.4f} {:20.4f} {:20.4f} {:20.4f}".format(
r, e_rho, e_u, e_p, e_T)
model_path = './models/' + start_time + '/'
os.mkdir(model_path)
# Parameter settings
EPOCH = 50
LR = 0.01
BATCH_SIZE_TRAIN = 4
BATCH_SIZE_TEST = 64
INPUT_SIZE = 72
TIME_STEP = 10
HIDDEN_UNIT_SIZE = 40
NO_CLASS = 3
# Dataloaders
trainloader,testloader = getData(data_path,label_path,BATCH_SIZE_TRAIN,BATCH_SIZE_TEST)
# Initialize Model
ecg = ECG()
print ecg
ecg = ecg.cuda()
#Loss function
optimizer = torch.optim.SGD(ecg.parameters(),lr=LR)
loss_func = nn.CrossEntropyLoss()
# Training
for epoch in range(EPOCH):
for step,(x,y) in enumerate(trainloader):
# print x.size()
x = x.view(-1,TIME_STEP,INPUT_SIZE)
def model():
problems = ['test1', 'test2', 'test3', 'test4']
runs = ['exact', 'MC-ev', 'MC-ev-CGF']
labels = ['exact', 'Castro + CG', 'Castro + CGF']
markers = ["o", "x", "+", "*", "D", "h"]
colors = ["r", "b", "c", "g", "m", "0.5"]
symsize = [12, 12, 25, 15, 10, 10]
xmax = {"test1": 1.e6, "test2": 1.e5, "test3": 2.e5, "test4": 1.e5}
for p in problems:
print "working on problem: ", p
# read in all the data, store in a dictionary
data = {}
print " ..reading in data"
for r in runs:
if r == "exact":
modelData = dataRead.getData("exact/%s.exact.128.out" % (p))
vars = dataObj()
vars.x = modelData[:, 1]
vars.rho = modelData[:, 2]
vars.u = modelData[:, 3]
vars.p = modelData[:, 4]
vars.T = modelData[:, 5]
vars.e = modelData[:, 6]
data[r] = vars
elif r == "flash":
modelData = dataRead.getData("flash/%s/flash.par.%s.data" %
(p, p))
vars = dataObj()
vars.x = modelData[:, 0]
vars.rho = modelData[:, 1]
vars.T = modelData[:, 3]
vars.u = modelData[:, 4]
vars.p = modelData[:, 2]
vars.e = modelData[:, 5]
data[r] = vars
else:
# find the last slice file with our pattern
files = []
for f in os.listdir(r):
if fnmatch.fnmatch(f, "%s*plt?????.slice" % (p)):
files.append(f)
files.sort()
dataFile = files[len(files) - 1]
modelData = dataRead.getData("%s/%s" % (r, dataFile))
vars = dataObj()
vars.x = modelData[:, 0]
vars.rho = modelData[:, 1]
vars.u = modelData[:, 2] / modelData[:, 1]
vars.p = modelData[:, 10]
vars.T = modelData[:, 6]
vars.e = modelData[:, 5] / vars.rho
data[r] = vars
# done reading
print " ..making plots"
pylab.rc("font", size=9)
pylab.rc("legend", loc="best")
#pylab.ticklabel_format(style='sci', axis='x', scilimits=(-3,3), useMathText=True )
fmt = pylab.ScalarFormatter(useMathText=True, useOffset=False)
fmt.set_powerlimits((-3, 3))
#----------------------------------------------------------------------
# plots
#----------------------------------------------------------------------
pylab.clf()
vars = ["density", "velocity", "pressure", "temperature", "gammae"]
units = ["(g/cc)", "(cm/s)", "(erg/cc)", "(K)", ""]
for v in vars:
if v == "density":
pylab.subplot(321)
elif v == "velocity":
pylab.subplot(322)
elif v == "pressure":
pylab.subplot(323)
elif v == "temperature":
pylab.subplot(324)
elif v == "gammae":
pylab.subplot(325)
isym = 0
for r, l in zip(runs, labels):
if v == "density":
varData = data[r].rho
elif v == "velocity":
varData = data[r].u
elif v == "pressure":
varData = data[r].p
elif v == "temperature":
varData = data[r].T
elif v == "gammae":
varData = data[r].p / (data[r].rho * data[r].e) + 1.0
if (r == "exact"):
pylab.plot(data[r].x, varData, label=l, c="k")
else:
pylab.plot(data[r].x,
varData,
c=colors[isym],
ls=":",
zorder=-100,
alpha=0.75)
pylab.scatter(data[r].x,
varData,
label=l,
marker=markers[isym],
c=colors[isym],
s=7,
edgecolor=colors[isym])
isym += 1
pylab.xlabel("x")
if v == "gammae":
vl = r"$\gamma_e$"
else:
vl = v
pylab.ylabel(vl + " " + units[vars.index(v)])
if v == "density":
pylab.legend(frameon=False, fontsize=9)
ax = pylab.gca()
pylab.xlim(0, xmax[p])
ax.xaxis.set_major_formatter(fmt)
if v == "temperature":
ax.set_yscale('log')
else:
ax.yaxis.set_major_formatter(fmt)
f = pylab.gcf()
f.set_size_inches(7.0, 9.0)
pylab.tight_layout()
print "saving figure: %s-MC-CGF.png" % (p)
pylab.savefig("%s-MC-CGF.png" % (p))
pylab.savefig("%s-MC-CGF.eps" % (p))
#----------------------------------------------------------------------
# residual plots
#----------------------------------------------------------------------
pylab.clf()
for v in vars:
if v == "density":
pylab.subplot(321)
elif v == "velocity":
pylab.subplot(322)
elif v == "pressure":
pylab.subplot(323)
elif v == "temperature":
pylab.subplot(324)
elif v == "gammae":
pylab.subplot(325)
isym = 0
for r, l in zip(runs, labels):
if v == "density":
varData = data[r].rho
refData = data["exact"].rho
elif v == "velocity":
varData = data[r].u
refData = data["exact"].u
elif v == "pressure":
varData = data[r].p
refData = data["exact"].p
elif v == "temperature":
varData = data[r].T
refData = data["exact"].T
elif v == "gammae":
varData = data[r].p / (data[r].rho * data[r].e) + 1.0
refData = data["exact"].p / (data["exact"].rho *
data["exact"].e) + 1.0
if (r == "exact"):
pass
else:
# sanity check
print "grid agreement: {}".format(
numpy.max(data[r].x - data["exact"].x))
pylab.plot(data[r].x,
varData - refData,
c=colors[isym],
ls=":",
zorder=-100,
alpha=0.75)
pylab.scatter(data[r].x,
varData - refData,
label=l,
marker=markers[isym],
c=colors[isym],
s=7,
edgecolor=colors[isym])
isym += 1
pylab.xlabel("x")
if v == "gammae":
vl = r"$\gamma_e$"
else:
vl = v
pylab.ylabel("{} error {}".format(vl, units[vars.index(v)]))
if v == "density":
pylab.legend(frameon=False, fontsize=9)
ax = pylab.gca()
pylab.xlim(0, xmax[p])
ax.xaxis.set_major_formatter(fmt)
ax.yaxis.set_major_formatter(fmt)
f = pylab.gcf()
f.set_size_inches(7.0, 9.0)
pylab.tight_layout()
print "saving figure: %s-MC-CGF-resid.png" % (p)
pylab.savefig("%s-MC-CGF-resid.png" % (p))
pylab.savefig("%s-MC-CGF-resid.eps" % (p))
def model():
problems = ['test1', 'test2', 'test3', 'test4']
runs = ['exact', 'MC-ev', 'flash', 'flash-nochar'] #, 'flash-nosteep']
labels = ['exact', 'Castro + CGF', 'Flash', 'Flash (no char limiting)']
markers = ["o", "x", "+", "*", "D", "h"]
colors = ["r", "b", "c", "g", "m", "0.5"]
symsize = [12, 12, 25, 15, 10, 10]
xmax = {"test1":1.e6, "test2":1.e5, "test3":2.e5, "test4":1.e5}
for p in problems:
print "working on problem: ", p
# read in all the data, store in a dictionary
data = {}
print " ..reading in data"
for r in runs:
if r == "exact":
modelData = dataRead.getData("exact/%s.exact.128.out" % (p))
vars = dataObj()
vars.x = modelData[:,1]
vars.rho = modelData[:,2]
vars.u = modelData[:,3]
vars.p = modelData[:,4]
vars.T = modelData[:,5]
vars.e = modelData[:,6]
data[r] = vars
elif r == "flash":
modelData = dataRead.getData("flash/%s/flash.par.%s.data" % (p, p))
vars = dataObj()
vars.x = modelData[:,0]
vars.rho = modelData[:,1]
vars.T = modelData[:,3]
vars.u = modelData[:,4]
vars.p = modelData[:,2]
vars.e = modelData[:,5]
data[r] = vars
elif r == "flash-nochar":
modelData = dataRead.getData("flash/%s/flash.par.%s.nocharlimit.data" % (p, p))
vars = dataObj()
vars.x = modelData[:,0]
vars.rho = modelData[:,1]
vars.T = modelData[:,3]
vars.u = modelData[:,4]
vars.p = modelData[:,2]
vars.e = modelData[:,5]
data[r] = vars
elif r == "flash-nosteep":
modelData = dataRead.getData("flash/%s/flash.par.%s.nosteep.data" % (p, p))
vars = dataObj()
vars.x = modelData[:,0]
vars.rho = modelData[:,1]
vars.T = modelData[:,3]
vars.u = modelData[:,4]
vars.p = modelData[:,2]
vars.e = modelData[:,5]
data[r] = vars
else:
# find the last slice file with our pattern
files = []
for f in os.listdir(r):
if fnmatch.fnmatch(f, "%s*plt?????.slice" % (p)):
files.append(f)
files.sort()
dataFile = files[len(files)-1]
modelData = dataRead.getData("%s/%s" % (r, dataFile))
vars = dataObj()
vars.x = modelData[:,0]
vars.rho = modelData[:,1]
vars.u = modelData[:,2]/modelData[:,1]
vars.p = modelData[:,10]
vars.T = modelData[:,6]
vars.e = modelData[:,5]/vars.rho
data[r] = vars
# done reading
print " ..making plots"
pylab.rc("font", size=9)
pylab.rc("legend", loc="best")
#pylab.ticklabel_format(style='sci', axis='x', scilimits=(-3,3), useMathText=True )
fmt = pylab.ScalarFormatter(useMathText=True, useOffset=False)
fmt.set_powerlimits((-3,3))
#----------------------------------------------------------------------
# plots
#----------------------------------------------------------------------
pylab.clf()
vars = ["density", "velocity", "pressure", "temperature", "gammae"]
units = ["(g/cc)", "(cm/s)", "(erg/cc)", "(K)", ""]
for v in vars:
if v == "density":
pylab.subplot(321)
elif v == "velocity":
pylab.subplot(322)
elif v == "pressure":
pylab.subplot(323)
elif v == "temperature":
pylab.subplot(324)
elif v == "gammae":
pylab.subplot(325)
isym = 0
for r, l in zip(runs, labels):
if v == "density":
varData = data[r].rho
elif v == "velocity":
varData = data[r].u
elif v == "pressure":
varData = data[r].p
elif v == "temperature":
varData = data[r].T
elif v == "gammae":
varData = data[r].p/(data[r].rho * data[r].e) + 1.0
if (r == "exact"):
pylab.plot(data[r].x, varData, label=l, c="k")
else:
pylab.plot(data[r].x, varData, c=colors[isym], ls=":", zorder=-100, alpha=0.75)
pylab.scatter(data[r].x, varData, label=l,
marker=markers[isym], c=colors[isym], s=7, edgecolor=colors[isym])
isym += 1
pylab.xlabel("x")
if v == "gammae":
vl = r"$\gamma_e$"
else:
vl = v
pylab.ylabel(vl + " " + units[vars.index(v)])
if v == "density":
pylab.legend(frameon=False, fontsize=9)
ax = pylab.gca()
pylab.xlim(0, xmax[p])
ax.xaxis.set_major_formatter(fmt)
if v == "temperature":
ax.set_yscale('log')
else:
ax.yaxis.set_major_formatter(fmt)
if p == "test4" and v in ["density", "pressure", "temperature"]:
ax.set_yscale('log')
f = pylab.gcf()
f.set_size_inches(7.0,9.0)
pylab.tight_layout()
print "saving figure: %s-MC-final.png" % (p)
pylab.savefig("%s-MC-final.png" % (p))
pylab.savefig("%s-MC-final.eps" % (p))
#----------------------------------------------------------------------
# residual plots
#----------------------------------------------------------------------
pylab.clf()
for v in vars:
if v == "density":
pylab.subplot(321)
elif v == "velocity":
pylab.subplot(322)
elif v == "pressure":
pylab.subplot(323)
elif v == "temperature":
pylab.subplot(324)
elif v == "gammae":
pylab.subplot(325)
isym = 0
for r, l in zip(runs, labels):
if v == "density":
varData = data[r].rho
refData = data["exact"].rho
elif v == "velocity":
varData = data[r].u
refData = data["exact"].u
elif v == "pressure":
varData = data[r].p
refData = data["exact"].p
elif v == "temperature":
varData = data[r].T
refData = data["exact"].T
elif v == "gammae":
varData = data[r].p/(data[r].rho * data[r].e) + 1.0
refData = data["exact"].p/(data["exact"].rho * data["exact"].e) + 1.0
if (r == "exact"):
pass
else:
# sanity check
if not numpy.max(data[r].x - data["exact"].x) == 0.0:
print "grid differences with {}: max error = {}".format(r, numpy.max(data[r].x - data["exact"].x))
pylab.plot(data[r].x, varData-refData, c=colors[isym], ls=":", zorder=-100, alpha=0.75)
pylab.scatter(data[r].x, varData-refData, label=l,
marker=markers[isym], c=colors[isym], s=7, edgecolor=colors[isym])
isym += 1
pylab.xlabel("x")
if v == "gammae":
vl = r"$\gamma_e$"
else:
vl = v
pylab.ylabel("{} error {}".format(vl, units[vars.index(v)]))
if v == "density":
pylab.legend(frameon=False, fontsize=9)
ax = pylab.gca()
pylab.xlim(0, xmax[p])
ax.xaxis.set_major_formatter(fmt)
ax.yaxis.set_major_formatter(fmt)
f = pylab.gcf()
f.set_size_inches(7.0,9.0)
pylab.tight_layout()
print "saving figure: %s-MC-final-resid.png" % (p)
pylab.savefig("%s-MC-final-resid.png" % (p))
pylab.savefig("%s-MC-final-resid.eps" % (p))
def model():
problems = ['test1', 'test2', 'test3']
runs = ['exact', 'MC', 'CW', 'ppmT-I', 'ppmT-II', 'ppmT-III']
markers = ["o", "x", "+", "*", "D", "h"]
colors = ["r", "b", "c", "g", "m", "0.5"]
xmax = {"test1":1.e6, "test2":1.e5, "test3":2.e5}
for p in problems:
print "working on problem: ", p
# read in all the data, store in a dictionary
data = {}
print " ..reading in data"
for r in runs:
if r == "exact":
modelData = dataRead.getData("exact/%s.exact.out" % (p))
vars = dataObj()
vars.x = modelData[:,1]
vars.rho = modelData[:,2]
vars.u = modelData[:,3]
vars.p = modelData[:,4]
vars.T = modelData[:,5]
data[r] = vars
else:
# find the last slice file with our pattern
files = []
for f in os.listdir(r):
if fnmatch.fnmatch(f, "%s*plt?????.slice" % (p)):
files.append(f)
files.sort()
dataFile = files[len(files)-1]
modelData = dataRead.getData("%s/%s" % (r, dataFile))
vars = dataObj()
vars.x = modelData[:,0]
vars.rho = modelData[:,1]
vars.u = modelData[:,2]/modelData[:,1]
vars.p = modelData[:,10]
vars.T = modelData[:,6]
data[r] = vars
# done reading
print " ..making plots"
pylab.rc("font", size=9)
pylab.rc("legend", loc="best")
#pylab.ticklabel_format(style='sci', axis='x', scilimits=(-3,3), useMathText=True )
fmt = pylab.ScalarFormatter(useMathText=True, useOffset=False)
fmt.set_powerlimits((-3,3))
pylab.clf()
#-------------------------------------------------------------------------
# density plot
#-------------------------------------------------------------------------
pylab.subplot(221)
isym = 0
for r in runs:
if (r == "exact"):
pylab.plot(data[r].x, data[r].rho, label=r, c="k")
else:
pylab.scatter(data[r].x, data[r].rho, label=r,
marker=markers[isym], c=colors[isym], s=7, edgecolor=colors[isym])
isym += 1
pylab.xlabel("x")
pylab.ylabel("density (g/cc)")
pylab.legend(frameon=False, fontsize=9)
ax = pylab.gca()
pylab.xlim(0, xmax[p])
ax.xaxis.set_major_formatter(fmt)
ax.yaxis.set_major_formatter(fmt)
#-------------------------------------------------------------------------
# velocity plot
#-------------------------------------------------------------------------
pylab.subplot(222)
isym = 0
for r in runs:
if (r == "exact"):
pylab.plot(data[r].x, data[r].u, label=r, c="k")
else:
pylab.scatter(data[r].x, data[r].u, label=r,
marker=markers[isym], c=colors[isym], s=7, edgecolor=colors[isym])
isym += 1
pylab.xlabel("x")
pylab.ylabel("velocity (cm/s)")
pylab.legend(frameon=False, fontsize=9)
ax = pylab.gca()
pylab.xlim(0, xmax[p])
ax.xaxis.set_major_formatter(fmt)
ax.yaxis.set_major_formatter(fmt)
#-------------------------------------------------------------------------
# pressure plot
#-------------------------------------------------------------------------
pylab.subplot(223)
isym = 0
for r in runs:
if (r == "exact"):
pylab.plot(data[r].x, data[r].p, label=r, c="k")
else:
pylab.scatter(data[r].x, data[r].p, label=r,
marker=markers[isym], c=colors[isym], s=7, edgecolor=colors[isym])
isym += 1
pylab.xlabel("x")
pylab.ylabel("pressure (erg/cc)")
pylab.legend(frameon=False, fontsize=9)
ax = pylab.gca()
pylab.xlim(0, xmax[p])
ax.xaxis.set_major_formatter(fmt)
ax.yaxis.set_major_formatter(fmt)
#-------------------------------------------------------------------------
# temperature plot
#-------------------------------------------------------------------------
pylab.subplot(224)
isym = 0
for r in runs:
if (r == "exact"):
pylab.plot(data[r].x, data[r].T, label=r, c="k")
else:
pylab.scatter(data[r].x, data[r].T, label=r,
marker=markers[isym], c=colors[isym], s=7, edgecolor=colors[isym])
isym += 1
pylab.xlabel("x")
pylab.ylabel("temperature (K)")
pylab.legend(frameon=False, fontsize=9)
ax = pylab.gca()
ax.set_yscale('log')
pylab.xlim(0, xmax[p])
ax.xaxis.set_major_formatter(fmt)
#ax.yaxis.set_major_formatter(fmt)
f = pylab.gcf()
f.set_size_inches(7.0,9.0)
pylab.tight_layout()
print "saving figure: %s.png" % (p)
pylab.savefig("%s.png" % (p))
pylab.savefig("%s.eps" % (p))
def model():
problems = ['test1', 'test2', 'test3']
runs = ['exact', 'CW', 'CW-ev', 'flash', 'flash-nochar', 'MC', 'MC-ev', 'MC-ppmT-I-ev', 'MC-ppmT-II-ev', 'MC-ppmT-III-ev']
for p in problems:
print "working on problem: ", p
# read in all the data, store in a dictionary
data = {}
for r in runs:
if r == "exact":
modelData = dataRead.getData("exact/%s.exact.128.out" % (p))
vars = dataObj()
vars.x = modelData[:,1]
vars.rho = modelData[:,2]
vars.u = modelData[:,3]
vars.p = modelData[:,4]
vars.T = modelData[:,5]
data[r] = vars
elif r == "flash":
modelData = dataRead.getData("flash/%s/flash.par.%s.data" % (p, p))
vars = dataObj()
vars.x = modelData[:,0]
vars.rho = modelData[:,1]
vars.T = modelData[:,3]
vars.u = modelData[:,4]
vars.p = modelData[:,2]
data[r] = vars
elif r == "flash-nochar":
modelData = dataRead.getData("flash/%s/flash.par.%s.nocharlimit.data" % (p, p))
vars = dataObj()
vars.x = modelData[:,0]
vars.rho = modelData[:,1]
vars.T = modelData[:,3]
vars.u = modelData[:,4]
vars.p = modelData[:,2]
data[r] = vars
else:
# find the last slice file with our pattern
files = []
for f in os.listdir(r):
if fnmatch.fnmatch(f, "%s*plt?????.slice" % (p)):
files.append(f)
files.sort()
dataFile = files[len(files)-1]
modelData = dataRead.getData("%s/%s" % (r, dataFile))
vars = dataObj()
vars.x = modelData[:,0]
vars.rho = modelData[:,1]
vars.u = modelData[:,2]/modelData[:,1]
vars.p = modelData[:,10]
vars.T = modelData[:,6]
data[r] = vars
# done reading
print " "
print "problem: {}".format(p)
print "L2 norm"
print "{:^20s} {:^20s} {:^20s} {:^20s} {:^20s}".format("run", "rho", "u", "p", "T")
for r in runs:
e_rho = numpy.linalg.norm((data[r].rho - data["exact"].rho)/data["exact"].rho)
e_u = numpy.linalg.norm((data[r].u - data["exact"].u)/data["exact"].u)
e_p = numpy.linalg.norm((data[r].p - data["exact"].p)/data["exact"].p)
e_T = numpy.linalg.norm((data[r].T - data["exact"].T)/data["exact"].T)
print "{:20s} {:20g} {:20g} {:20g} {:20g}".format(r, e_rho, e_u, e_p, e_T)
print " "
print "L-infty norm"
print "{:^20s} {:^20s} {:^20s} {:^20s} {:^20s}".format("run", "rho", "u", "p", "T")
for r in runs:
e_rho = numpy.max(numpy.abs(data[r].rho - data["exact"].rho)/data["exact"].rho)
e_u = numpy.max(numpy.abs(data[r].u - data["exact"].u)/data["exact"].u)
e_p = numpy.max(numpy.abs(data[r].p - data["exact"].p)/data["exact"].p)
e_T = numpy.max(numpy.abs(data[r].T - data["exact"].T)/data["exact"].T)
print "{:20s} {:20g} {:20g} {:20g} {:20g}".format(r, e_rho, e_u, e_p, e_T)
