def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "broken-dam-old.inp")
gold = tenv.output("broken-dam-old_golden/broken-dam-old.h5")
time = output.time(2)
# test final cycle number
cycle = output.cycle(2)
cycleg = gold.cycle(2)
status = "PASS" if cycle == cycleg else "FAIL"
print("{:s} : matching final cycle numbers".format(status))
if cycle != cycleg: nfail += 1
# test final fluid volume fraction
vof = output.field(2, "VOF")[:, 0]
vofg = gold.field(2, "VOF")[:, 0]
nfail += truchas.compare_max(vof, vofg, 1e-9, "vof", time)
# test final velocity
vel = output.field(2, "Z_VC")
velg = gold.field(2, "Z_VC")
nfail += truchas.compare_max(vel[:, 0], velg[:, 0], 1e-9, "vel-x", time)
nfail += truchas.compare_max(vel[:, 1], velg[:, 1], 1e-9, "vel-y", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "diverging-duct-old-1c.inp")
xc = output.centroids()
time = output.time(2)
# pressure
pressure = output.field(2, "Z_P")
pex = 2.5 - 2 / (xc[:, 1]**2 + 0.5 * (xc[:, 0] + xc[:, 2])**2)
nfail += truchas.compare_max_rel(pressure, pex, 0.16, "pressure", time)
# velocity
velocity = output.field(2, "Z_VC")
uex = 0.5 * (xc[:, 0] + xc[:, 2]) / (xc[:, 1]**2 + 0.5 *
(xc[:, 0] + xc[:, 2])**2)
vex = xc[:, 1] / (xc[:, 1]**2 + 0.5 * (xc[:, 0] + xc[:, 2])**2)
uerr = (velocity[:, 0] - uex) / max(abs(uex))
verr = (velocity[:, 1] - vex) / max(abs(vex))
werr = (velocity[:, 2] - uex) / max(abs(uex))
nfail += truchas.compare_max(uerr, 0, 0.02, "x-velocity", time)
nfail += truchas.compare_max(verr, 0, 0.1, "y-velocity", time)
nfail += truchas.compare_max(werr, 0, 0.1, "z-velocity", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "inflow-bc-2.inp")
xc = output.centroids()
time = output.time(2)
# pressure
pressure = output.field(2, "Z_P")
nfail += truchas.compare_max(pressure, 0, 1e-15, "pressure", time)
# vof
vof = output.field(2, "VOF")[:, 0]
p = 0.25 * time - 0.375
vofex = sp.array([
1 if x + 0.125 < p else 0 if x - 0.125 > p else 4 * (p - (x - 0.125))
for x in xc[:, 0]
])
nfail += truchas.compare_max(vof, vofex, 1e-15, "vof", time)
# the x-velocity is 0.25 in cells containing fluid
vel = output.field(2, "Z_VC")
velex = sp.array([[0.25 if vf > 0 else 0, 0, 0] for vf in vof])
nfail += truchas.compare_max(vel, velex, 1e-15, "velocity", time)
# temperature is 2 in cells containing fluid
temp = output.field(2, "Z_TEMP")
tempex = sp.array([2 if vf > 0 else 0 for vf in vof])
nfail += truchas.compare_max(temp, tempex, 1e-15, "temperature", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "steady-flow-6a.inp")
# From a special run to compute vof for final exact configuration
gold = tenv.output("steady-flow-6a_golden/steady-flow-6a.h5")
# Test final VOFs against golden output
vof_output = output.field(2, "VOF")[:, 0]
vof_gold = gold.field(1, "VOF")[:, 0]
nfail += truchas.compare_max(vof_output, vof_gold, 0.09, "VOF",
output.time(2))
# max <= l2 <= sqrt(ncell)*max = 31*max
nfail += truchas.compare_l2(vof_output, vof_gold, 3 * 0.09, "VOF",
output.time(2))
# Test final velocity against exact
velocity = output.field(2, "Z_VC")
velocity[:, 0] -= 4
velocity[:, 1] -= 3
nfail += truchas.compare_max(velocity, 0, 1e-13, "velocity",
output.time(2))
# Test pressure against exact
nfail += truchas.compare_max(output.field(1, "Z_P"), 0, 1e-10, "pressure",
output.time(1))
nfail += truchas.compare_max(output.field(2, "Z_P"), 0, 1e-10, "pressure",
output.time(2))
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "tangential-surface-tension-couette.inp")
xc = output.centroids()
# verify final fields
sid = 2
time = output.time(sid)
# temperature
test = output.field(sid, "Z_TEMP")
minx = min(xc[:, 0]) - 0.5
Tref = 1 + (xc[:, 0] - minx)
nfail += truchas.compare_max(test, Tref, 1e-8, "temp", time)
# pressure
test = output.field(sid, "Z_P")
nfail += truchas.compare_max(test, 0, 1e-8, "pressure", time)
# velocity
test = output.field(sid, "Z_VC")
dsig_dx = -1
viscosity = 20
minz = min(xc[:, 2]) - 0.5
nfail += truchas.compare_max(test[:, 0],
dsig_dx / viscosity * (xc[:, 2] - minz), 1e-7,
"x-velocity", time)
nfail += truchas.compare_max(test[:, 1], 0, 1e-10, "y-velocity", time)
nfail += truchas.compare_max(test[:, 2], 0, 1e-10, "z-velocity", time)
truchas.report_summary(nfail)
return nfail
def velocity_test(velocity, tol, time):
nfail = 0
nfail += truchas.compare_max((velocity[:, 0] - 2 * time) / (2 * time), 0,
tol, "x-velocity", time)
nfail += truchas.compare_max(velocity[:, 1], 0, tol, "y-velocity", time)
nfail += truchas.compare_max(velocity[:, 2], 0, tol, "z-velocity", time)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "gap-rad-flow.inp")
probe_names = ["left end", "right end", "gap left", "gap right"]
probe_golden = {"left end": [1.499998474, 1.371828885],
"right end": [0.500001526, 0.628171115],
"gap left": [1.498533630, 1.370837833],
"gap right": [0.5014663700, 0.629162167]}
# verify initial probe data
time = output.probe(probe_names[0], "TEMP")[0, 1] # 0 is first cycle, 1 is time index
for pname in probe_names:
probe_data = output.probe(pname, "TEMP")[0,-1] # 0 for first cycle, -1 for temp data
nfail += truchas.compare_max(probe_data, probe_golden[pname][0], 1e-9, pname, time)
# verify final probe data
# get the last cycle
time = output.probe(probe_names[0], "TEMP")[-1, 1] # -1 is last cycle, 1 is time index
for pname in probe_names:
probe_data = output.probe(pname, "TEMP")[-1,-1] # -1 for last cycle, -1 for temp data
nfail += truchas.compare_max(probe_data, probe_golden[pname][1], 5e-5, pname, time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "pipe-flow-3a.inp")
flow_region = output.region(1)
xc = output.centroids()[flow_region]
# pressure
pex = 3 * (0.5 - xc[:, 0])
nfail += truchas.compare_max(
output.field(1, "Z_P")[flow_region], pex, 1e-13, "pressure",
output.time(1))
nfail += truchas.compare_max(
output.field(2, "Z_P")[flow_region], pex, 1e-11, "pressure",
output.time(2))
# velocity
test = output.field(2, "Z_VC")[flow_region]
uex = (1 - xc[:, 1]**2) / 2
time = output.time(2)
nfail += truchas.compare_max(test[:, 0], uex, 1.3e-3, "x-velocity", time)
nfail += truchas.compare_max(test[:, 1], 0, 1e-13, "y-velocity", time)
nfail += truchas.compare_max(test[:, 2], 0, 1e-13, "z-velocity", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "inviscid-pipe-flow-1d.inp")
# early velocity
time = output.time(2)
velocity = output.field(2, "Z_VC")
velex = sp.sqrt(2) * time
nfail += truchas.compare_max_rel(velocity[:, 0], velex, 1e-11,
"x-velocity", time)
nfail += truchas.compare_max_rel(velocity[:, 1], velex, 1e-11,
"y-velocity", time)
nfail += truchas.compare_max(velocity[:, 2], 0, 1e-12, "z-velocity", time)
# final velocity
time = output.time(3)
velocity = output.field(3, "Z_VC")
velex = sp.sqrt(2) * time
nfail += truchas.compare_max(velocity[:, 0], velex, 1e-12, "x-velocity",
time)
nfail += truchas.compare_max(velocity[:, 1], velex, 1e-12, "y-velocity",
time)
nfail += truchas.compare_max(velocity[:, 2], 0, 1e-13, "z-velocity", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "sloshing-flow.inp")
golden = tenv.output("sloshing-flow_pgolden/sloshing-flow.h5")
sid = 2
time = output.time(sid)
# cycle number
cycle = output.cycle(sid)
cycleg = golden.cycle(sid)
status = "PASS" if cycle == cycleg else "FAIL"
print("{:s}: matching cycle numbers {:d}".format(status, cycle))
if cycle != cycleg: nfail += 1
# temperature
test = output.field(sid, "Z_TEMP")
gold = golden.field(sid, "Z_TEMP")
nfail += truchas.compare_max(test, gold, 1e-6, "temp", time)
# fluid volume fraction
test = output.field(sid, "VOF")[:,0]
gold = golden.field(sid, "VOF")[:,0]
nfail += truchas.compare_max(test, gold, 1e-6, "vof", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "free-surf-flow-4.inp")
golden = tenv.output("free-surf-flow-4_golden/free-surf-flow-4.h5")
# initial
time = output.time(1)
test = output.field(1, "VOF")[:, 0]
gold = golden.field(1, "VOF")[:, 0]
nfail += truchas.compare_max(test, gold, 0, "vof", time)
test = output.field(1, "Z_P")
gold = golden.field(1, "Z_P")
nfail += truchas.compare_max(test, gold, 1e-13, "pressure", time)
# final time
time = output.time(2)
test = output.field(2, "VOF")[:, 0]
gold = golden.field(2, "VOF")[:, 0]
nfail += truchas.compare_max(test, gold, 1e-13, "vof", time)
test = output.field(2, "Z_P")
gold = golden.field(2, "Z_P")
nfail += truchas.compare_max(test, gold, 1e-13, "pressure", time)
test = output.field(2, "Z_VC")
gold = golden.field(2, "Z_VC")
nfail += truchas.compare_max(test, gold, 1e-13, "velocity", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "hydrostatic-10.inp")
xc = output.centroids()
# pressure
pex = (-2 + 0.05 * xc[:, 1]) * xc[:, 1]
pex -= sp.mean(pex)
Tex = 1.5 + xc[:, 1] / 10
for sid in (1, 2):
time = output.time(sid)
pressure = output.field(sid, "Z_P")
pressure -= sp.mean(pressure)
nfail += truchas.compare_max(pressure, pex, 1e-10, "pressure", time)
nfail += truchas.compare_max(output.field(sid, "Z_TEMP"), Tex, 1e-14,
"temperature", time)
# final velocity zero everywhere
nfail += truchas.compare_max(output.field(2, "Z_VC"), 0, 1e-13, "velocity",
output.time(2))
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "gap-rad-flow-old.inp")
probe_names = ["left_end", "right_end", "gap_left", "gap_right"]
probe_golden = {"left_end": [1.499998474, 1.371828885],
"right_end": [0.500001526, 0.628171115],
"gap_left": [1.498533630, 1.370837833],
"gap_right": [0.5014663700, 0.629162167]}
# verify initial probe data
for pname in probe_names:
filename = os.path.join(output.directory,pname + ".dat")
data = numpy.loadtxt(filename)
time = data[0,0]
probe_data = data[0,1]
nfail += truchas.compare_max(probe_data, probe_golden[pname][0], 1e-9, pname, time)
# verify final probe data
# get the last cycle
for pname in probe_names:
filename = os.path.join(output.directory,pname + ".dat")
data = numpy.loadtxt(filename)
time = data[-1,0]
probe_data = data[-1,1]
nfail += truchas.compare_max(probe_data, probe_golden[pname][1], 5e-5, pname, time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "htvoid4-old.inp")
golden = tenv.output("htvoid4-old_pgolden/htvoid4-old.h5")
# checking final values
sid = output.num_series()
time = output.time(sid)
# cycle number
cycle = output.cycle(sid)
cycleg = golden.cycle(sid)
status = "PASS" if cycle == cycleg else "FAIL"
print("{:s}: matching cycle numbers {:d}".format(status, cycle))
if cycle != cycleg: nfail += 1
# temperature
test = output.field(sid, "Z_TEMP")
gold = golden.field(sid, "Z_TEMP")
nfail += truchas.compare_max(test, gold, 1e-6, "temp", time)
# solid fraction
test = output.field(sid, "VOF")[:,1]
gold = golden.field(sid, "VOF")[:,1]
nfail += truchas.compare_max(test, gold, 1e-6, "vof", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "free-surf-flow-7.inp")
golden = tenv.output("free-surf-flow-7_golden/free-surf-flow-7.h5")
# final time
time = output.time(2)
vof = output.field(2, "VOF")[:, 0]
gold = golden.field(2, "VOF")[:, 0]
nfail += truchas.compare_max(vof, gold, 4e-2, "vof", time)
test = output.field(2, "Z_P")
gold = golden.field(2, "Z_P")
nfail += truchas.compare_max(test, gold, 1e-10, "pressure", time)
# the x-velocity is 1 in cells containing fluid
test = output.field(2, "Z_VC")
uerror = max(
abs(u - 2 / 3 * time) if vf > 0.0 else abs(u)
for u, vf in zip(test[:, 0], vof))
nfail += truchas.compare_max(uerror, 0, 1e-11, "x-velocity", time)
nfail += truchas.compare_max(test[:, 1], 0, 1e-11, "y-velocity", time)
nfail += truchas.compare_max(test[:, 2], 0, 1e-11, "z-velocity", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "steady-flow-2d.inp")
# Test VOFs against exact
xc = output.centroids()
t = output.time(2)
vof = output.field(2, "VOF")[:,0]
nfail += truchas.compare_max(vof, vof_ex(xc, t), 2e-13, "VOF", t)
t = output.time(3)
vof = output.field(3, "VOF")[:,0]
nfail += truchas.compare_max(vof, vof_ex(xc, t), 2e-13, "VOF", t)
# Test final velocity against exact
velocity = output.field(3, "Z_VC")
velocity[:,0] -= 2.82842712474619
velocity[:,1] -= 2.82842712474619
nfail += truchas.compare_max(velocity, 0, 1e-13, "velocity", output.time(3))
# Test pressure against exact
nfail += truchas.compare_max(output.field(1, "Z_P"), 0, 1e-10, "pressure", output.time(1))
nfail += truchas.compare_max(output.field(3, "Z_P"), 0, 1e-10, "pressure", output.time(3))
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "free-surf-flow-8.inp")
golden = tenv.output("free-surf-flow-8_golden/free-surf-flow-8.h5")
for sid in (1, 2):
time = output.time(sid)
vof = output.field(sid, "VOF")[:, 0]
gold = golden.field(sid, "VOF")[:, 0]
nfail += truchas.compare_max(vof, gold, 1e-13, "vof", time)
test = output.field(sid, "Z_P")
gold = golden.field(sid, "Z_P")
nfail += truchas.compare_max(test, gold, 1e-12, "pressure", time)
# ensure pressure is 0 in void
void_error = max(abs(p) for p, vf in zip(test, vof) if vf == 0)
nfail += truchas.compare_max(void_error, 0, 1e-12, "void-pressure",
time)
test = output.field(sid, "Z_VC")
gold = golden.field(sid, "Z_VC")
nfail += truchas.compare_max(test, gold, 1e-11, "velocity", time)
# the velocity is 0 in purely void cells
uerror = max(max(abs(u)) for u, vf in zip(test, vof) if vf == 0)
nfail += truchas.compare_max(uerror, 0, 1e-11, "void-velocity", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "free-surf-flow-1.inp")
xc = output.centroids()
# initial conditions
vof = output.field(1, "VOF")
nfail += vof_test(vof, xc, 5e-9, output.time(1))
nfail += truchas.compare_max(output.field(1, "Z_P"), 0, 1e-10, "pressure",
output.time(1))
nfail += velocity_test(output.field(1, "Z_VC"), vof[:, 0], 1e-13,
output.time(1))
# intermediate time
vof = output.field(2, "VOF")
nfail += vof_test(vof, xc, 5e-9, output.time(2))
nfail += truchas.compare_max(output.field(2, "Z_P"), 0, 1e-14, "pressure",
output.time(2))
nfail += velocity_test(output.field(2, "Z_VC"), vof[:, 0], 1e-14,
output.time(2))
# final time
vof = output.field(3, "VOF")
nfail += vof_test(vof, xc, 5e-9, output.time(3))
nfail += truchas.compare_max(output.field(3, "Z_P"), 0, 1e-14, "pressure",
output.time(3))
nfail += velocity_test(output.field(3, "Z_VC"), vof[:, 0], 1e-14,
output.time(3))
truchas.report_summary(nfail)
return nfail
def velocity_test(velocity, vof, tol, time):
# the x-velocity is 1 in cells containing fluid
nfail = 0
uerror = max(abs(u - 2/3*time) if vf > 0 else abs(u) for u,vf in zip(velocity[:,0],vof))
nfail += truchas.compare_max(uerror, 0, tol, "x-velocity", time)
nfail += truchas.compare_max(velocity[:,1], 0, tol, "y-velocity", time)
nfail += truchas.compare_max(velocity[:,2], 0, tol, "z-velocity", time)
return nfail
def compare_velocity(vel, vof, tol, time):
# the x-direction velocity is 1 in cells which aren't solidified
uerror = max(
abs(u - 1.) if vf < 1. else abs(u) for u, vf in zip(vel[:, 0], vof))
verror = max(abs(vel[:, 1]))
werror = max(abs(vel[:, 2]))
nfail = 0
nfail += truchas.compare_max(uerror, 0, tol, "x-velocity", time)
nfail += truchas.compare_max(verror, 0, tol, "y-velocity", time)
nfail += truchas.compare_max(werror, 0, tol, "z-velocity", time)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4,
"ustruc2.inp",
restart_file="ustruc1.restart.149")
golden = tenv.output("ustruc2_pgolden/ustruc2.h5")
time = output.time(2) # final time
# temperature
test = output.field(2, "Z_TEMP")
gold = golden.field(3, "Z_TEMP")
nfail += truchas.compare_max_rel(test, gold, 5e-5, "temp", time)
# G
tol = 1e-4
test = sp.ma.masked_values(output.field(2, "uStruc-G"), 0)
gold = sp.ma.masked_values(golden.field(3, "uStruc-G"), 0)
error = abs((test - gold) / (200 / tol + gold))
nfail += truchas.compare_max(error, 0, tol, "G", time)
# V
tol = 1e-4
test = sp.ma.masked_values(output.field(2, "uStruc-V"), 0)
gold = sp.ma.masked_values(golden.field(3, "uStruc-V"), 0)
error = abs((test - gold) / (1e-4 / tol + gold))
nfail += truchas.compare_max(error, 0, tol, "V", time)
# lambda1
tol = 1e-4
test = sp.ma.masked_values(output.field(2, "uStruc-gv1-lambda1"), 0)
gold = sp.ma.masked_values(golden.field(3, "uStruc-gv1-lambda1"), 0)
error = abs((test - gold) / (4e-6 / tol + gold))
nfail += truchas.compare_max(error, 0, tol, "lambda1", time)
# lambda2
tol = 1e-4
test = sp.ma.masked_values(output.field(2, "uStruc-gv1-lambda2"), 0)
gold = sp.ma.masked_values(golden.field(3, "uStruc-gv1-lambda2"), 0)
error = abs((test - gold) / (2e-6 / tol + gold))
nfail += truchas.compare_max(error, 0, tol, "lambda2", time)
# ustruc
test = output.field(2, "uStruc-gv1-ustruc")
gold = golden.field(3, "uStruc-gv1-ustruc")
success = (test == gold).all()
print("{:s}: {:s} at t={:8.2e}".format("PASS" if success else "FAIL",
"ustruc", time))
if not success: nfail += 1
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "void-collapse.inp")
# ZJJ: This velocity test looks for cycle 113, but the test only runs to cycle 30.
# It was also written with a function name that was overwritten by the later
# velocity test, so it was never run. As of March 2019 it would fail if renamed,
# so I've commented it out here to skip as was done indirectly before.
# # velocity
# sid = output.series_id(113)
# time = output.time(sid)
# test = output.field(sid, "Z_VC")
# nfail += truchas.compare_max_rel(test[:,0], 0.5, 5e-8, "x-velocity", time)
# nfail += truchas.compare_max(test[:,1], 0, 5e-10, "y-velocity", time)
# nfail += truchas.compare_max(test[:,2], 0, 5e-10, "z-velocity", time)
# pressure at cycle 1
# This test seems to check some numerical discretization
# transient that I do not understand. DAK 8-24-10
sid = output.series_id(1)
time = output.time(sid)
vof = output.field(sid, "VOF")[:, 0]
test = sp.ma.masked_where(vof < 0.01, output.field(sid,
"Z_P")).compressed()
P_anal = sp.array([
65.9934, 55.9944, 45.9954, 35.9964, 25.9974, 15.9984, 5.9994, 0.49995
])
nfail += truchas.compare_max(test, P_anal, 1e-3, "pressure", time)
# pressure at cycle 2
sid = output.series_id(2)
time = output.time(sid)
test = sp.ma.masked_where(vof < 0.01, output.field(sid,
"Z_P")).compressed()
nfail += truchas.compare_max(test, 0, 1e-3, "pressure", time)
# void volume fraction at cycle 30
sid = output.series_id(30)
time = output.time(sid)
test = output.field(sid, "VOF")[9, 1] # void volume fraction in cell 10
nfail += truchas.compare_max(test, 3e-4, 1e-7, "void fraction", time)
# x-velocity at cycle 30
test = output.field(sid, "Z_VC")[:, 0]
nfail += truchas.compare_max(test, 0.9999, 1e-4, "x-velocity", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "freezing-flow-1.inp")
golden = tenv.output("freezing-flow-1_pgolden/freezing-flow-1.h5")
# early time
time = output.time(2)
nfail += truchas.compare_max(output.field(2, "Z_TEMP"),
golden.field(2, "Z_TEMP"), 5e-7, "temp", time)
nfail += truchas.compare_max(output.field(2, "Z_P"), 0, 1e-10, "temp",
time)
nfail += truchas.compare_max(output.field(2, "Z_VC"), 0, 1e-10, "velocity",
time)
nfail += truchas.compare_max(
output.field(2, "VOF")[:, 0],
golden.field(2, "VOF")[:, 0], 5e-7, "vof", time)
# final time
time = output.time(3)
nfail += truchas.compare_max(output.field(3, "Z_TEMP"),
golden.field(3, "Z_TEMP"), 5e-6, "temp", time)
nfail += truchas.compare_max(output.field(3, "Z_P"), 0, 1e-10, "temp",
time)
nfail += truchas.compare_max(output.field(3, "Z_VC"), 0, 1e-10, "velocity",
time)
nfail += truchas.compare_max(
output.field(3, "VOF")[:, 0],
golden.field(3, "VOF")[:, 0], 1e-10, "vof", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "pipe-flow-1c.inp")
xc = output.centroids()
uex = (1 - xc[:, 1]**2) / (2 * sp.sqrt(2))
time = output.time(2)
test = output.field(2, "Z_VC")
nfail += truchas.compare_max(test[:, 0], uex, 1.3e-3, "x-velocity", time)
nfail += truchas.compare_max(test[:, 1], 0, 5e-12, "y-velocity", time)
nfail += truchas.compare_max(test[:, 2], uex, 1.3e-3, "z-velocity", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "hydrostatic-old.inp")
xc = output.centroids()
cycle = 20
sid = output.series_id(cycle)
time = output.time(sid)
# pressure
vof = output.field(sid, "VOF")[:, 0]
pressure = sp.array(
[p for p, vf in zip(output.field(sid, "Z_P"), vof) if vf > 0.99])
pressure -= sp.mean(pressure)
dpdz = -9.81e3
pex = [dpdz * z for z, vf in zip(xc[:, 2], vof) if vf > 0.99]
pex -= sp.mean(pex)
error = spla.norm(pressure - pex) / sp.sqrt(pex.size)
nfail += truchas.compare_l2(error, 0, 1e-5, "pressure", time)
# velocity zero everywhere
nfail += truchas.compare_max(output.field(sid, "Z_VC"), 0, 1e-9,
"velocity", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "ds11.inp")
golden = tenv.output("ds11_pgolden/ds11.h5")
test_region = output.region(1, 2)
gold_region = golden.region(1, 2)
# cycle number
for sid in (2, 4):
cycle = output.cycle(sid)
cycleg = golden.cycle(sid)
status = "PASS" if cycle == cycleg else "FAIL"
print("{:s}: matching cycle numbers {:d}".format(status, cycle))
if cycle != cycleg: nfail += 1
# fields
for sid in (3, 4):
time = output.time(sid)
test = output.field(sid, "Z_TEMP")[test_region]
gold = golden.field(sid, "Z_TEMP")[gold_region]
nfail += truchas.compare_max_rel(test, gold, 1e-6, "temp", time)
test = output.field(sid, "VOF")[:, 2] # comp 2 is fluid
gold = golden.field(sid, "VOF")[:, 2]
nfail += truchas.compare_max(test, gold, 1e-7, "vof", time)
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "ds10.inp")
xc = output.centroids()
# test final temp
nseries = output.num_series()
T = output.field(nseries, "Z_TEMP")
error = sp.empty(T.shape[0])
for j in range(error.shape[0]):
if min(abs(xc[j, :2])) < 1e-3:
# exclude gap cells from error calc
error[j] = 0
else:
Tref = sum(xc[j, :2])
if xc[j, 0] < 0:
if xc[j, 1] < 0:
Tref += 2.5
else:
Tref += 2.7
else:
if xc[j, 1] < 0:
Tref += 3.3
else:
Tref += 3.5
error[j] = abs(T[j] - Tref) / Tref
nfail += truchas.compare_max(error, 0, 1e-7, "temperature",
output.time(nseries))
truchas.report_summary(nfail)
return nfail
def velocity_test(velocity, tol, time):
nfail = 0
velex = sp.sqrt(2)*time
nfail += truchas.compare_max_rel(velocity[:,0], velex, tol, "x-velocity", time)
nfail += truchas.compare_max_rel(velocity[:,1], velex, tol, "y-velocity", time)
nfail += truchas.compare_max(velocity[:,2], 0, tol, "z-velocity", time)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "hydrostatic-old-7a.inp")
xc = output.centroids()
# pressure
pex = sp.array([
-2 * (z - sp.sqrt(3)) if z < sp.sqrt(3) else -(z - sp.sqrt(3))
for z in xc[:, 2]
])
pex -= sp.mean(pex)
for sid in (1, 2):
pressure = output.field(sid, "Z_P")
pressure -= sp.mean(pressure)
error = spla.norm(pressure - pex) / pex.size
nfail += truchas.compare_l2(error, 0, 8e-3, "pressure",
output.time(sid))
# velocity zero everywhere
nfail += truchas.compare_max(output.field(2, "Z_VC"), 0, 1e-13, "velocity",
output.time(2))
truchas.report_summary(nfail)
return nfail
def run_test(tenv):
nfail = 0
stdout, output = tenv.truchas(4, "ds8-old.inp")
golden = tenv.output("ds8-old_pgolden/ds8-old.h5")
for sid in (2, 4):
time = output.time(sid)
# cycle number
cycle = output.cycle(sid)
cycleg = golden.cycle(sid)
status = "PASS" if cycle == cycleg else "FAIL"
print("{:s}: matching cycle numbers {:d}".format(status, cycle))
if cycle != cycleg: nfail += 1
# fields
test = output.field(sid, "Z_TEMP")
gold = golden.field(sid, "Z_TEMP")
nfail += truchas.compare_max_rel(test, gold, 1e-6, "temp", time)
test = output.field(sid, "Z_VC")
gold = golden.field(sid, "Z_VC")
nfail += truchas.compare_max(test, gold, 1e-10, "velocity", time)
truchas.report_summary(nfail)
return nfail
