def main(final_time=1, write_output=False):
from hedge.backends import guess_run_context
rcon = guess_run_context()
from hedge.tools import EOCRecorder, to_obj_array
eoc_rec = EOCRecorder()
if rcon.is_head_rank:
from hedge.mesh import make_box_mesh
mesh = make_box_mesh((0, 0, 0), (10, 10, 10), max_volume=0.5)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [3, 4, 5]:
discr = rcon.make_discretization(mesh_data,
order=order,
default_scalar_type=numpy.float64)
from hedge.visualization import SiloVisualizer, VtkVisualizer
vis = VtkVisualizer(discr, rcon, "sinewave-%d" % order)
#vis = SiloVisualizer(discr, rcon)
sinewave = SineWave()
fields = sinewave.volume_interpolant(0, discr)
gamma, mu, prandtl, spec_gas_const = sinewave.properties()
from hedge.mesh import TAG_ALL
from hedge.models.gas_dynamics import GasDynamicsOperator
op = GasDynamicsOperator(dimensions=mesh.dimensions,
gamma=gamma,
mu=mu,
prandtl=prandtl,
spec_gas_const=spec_gas_const,
bc_inflow=sinewave,
bc_outflow=sinewave,
bc_noslip=sinewave,
inflow_tag=TAG_ALL,
source=None)
euler_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = euler_ex(t, q)
max_eigval[0] = speed
return ode_rhs
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
from hedge.timestep import RK4TimeStepper
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_name = ("euler-sinewave-%(order)d-%(els)d.dat" % {
"order": order,
"els": len(mesh.elements)
})
else:
log_name = False
logmgr = LogManager(log_name, "w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=final_time,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
for step, t, dt in step_it:
#if step % 10 == 0:
if write_output:
visf = vis.make_file("sinewave-%d-%04d" % (order, step))
#from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(
visf,
[
("rho",
discr.convert_volume(op.rho(fields),
kind="numpy")),
("e",
discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u",
discr.convert_volume(op.rho_u(fields),
kind="numpy")),
("u",
discr.convert_volume(op.u(fields), kind="numpy")),
#("true_rho", op.rho(true_fields)),
#("true_e", op.e(true_fields)),
#("true_rho_u", op.rho_u(true_fields)),
#("true_u", op.u(true_fields)),
#("rhs_rho", op.rho(rhs_fields)),
#("rhs_e", op.e(rhs_fields)),
#("rhs_rho_u", op.rho_u(rhs_fields)),
],
#expressions=[
#("diff_rho", "rho-true_rho"),
#("diff_e", "e-true_e"),
#("diff_rho_u", "rho_u-true_rho_u", DB_VARTYPE_VECTOR),
#("p", "0.4*(e- 0.5*(rho_u*u))"),
#],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
finally:
vis.close()
logmgr.close()
discr.close()
true_fields = sinewave.volume_interpolant(t, discr)
eoc_rec.add_data_point(order, discr.norm(fields - true_fields))
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
def main(write_output=True):
from hedge.backends import guess_run_context
rcon = guess_run_context(
#["cuda"]
)
gamma = 1.4
# at A=1 we have case of isentropic vortex, source terms
# arise for other values
densityA = 2.0
from hedge.tools import EOCRecorder, to_obj_array
eoc_rec = EOCRecorder()
if rcon.is_head_rank:
from hedge.mesh import \
make_rect_mesh, \
make_centered_regular_rect_mesh
refine = 1
mesh = make_centered_regular_rect_mesh((0,-5), (10,5), n=(9,9),
post_refine_factor=refine)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [4,5]:
discr = rcon.make_discretization(mesh_data, order=order,
debug=[#"cuda_no_plan",
#"print_op_code"
],
default_scalar_type=numpy.float64)
from hedge.visualization import SiloVisualizer, VtkVisualizer
#vis = VtkVisualizer(discr, rcon, "vortex-%d" % order)
vis = SiloVisualizer(discr, rcon)
vortex = Vortex(beta=5, gamma=gamma,
center=[5,0],
velocity=[1,0], densityA=densityA)
fields = vortex.volume_interpolant(0, discr)
sources=SourceTerms(beta=5, gamma=gamma,
center=[5,0],
velocity=[1,0], densityA=densityA)
from hedge.models.gas_dynamics import (
GasDynamicsOperator, GammaLawEOS)
from hedge.mesh import TAG_ALL
op = GasDynamicsOperator(dimensions=2,
mu=0.0, prandtl=0.72, spec_gas_const=287.1,
equation_of_state=GammaLawEOS(vortex.gamma),
bc_inflow=vortex, bc_outflow=vortex, bc_noslip=vortex,
inflow_tag=TAG_ALL, source=sources)
euler_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = euler_ex(t, q)
max_eigval[0] = speed
return ode_rhs
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
# limiter setup -------------------------------------------------------
from hedge.models.gas_dynamics import SlopeLimiter1NEuler
limiter = SlopeLimiter1NEuler(discr, gamma, 2, op)
# time stepper --------------------------------------------------------
from hedge.timestep import SSPRK3TimeStepper, RK4TimeStepper
#stepper = SSPRK3TimeStepper(limiter=limiter)
#stepper = SSPRK3TimeStepper()
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "euler-%d.dat" % order
else:
log_file_name = None
logmgr = LogManager(log_file_name, "w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
t = 0
#fields = limiter(fields)
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=.1,
#max_steps=500,
logmgr=logmgr,
max_dt_getter=lambda t: 0.4*op.estimate_timestep(discr,
stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
for step, t, dt in step_it:
if step % 1 == 0 and write_output:
#if False:
visf = vis.make_file("vortex-%d-%04d" % (order, step))
true_fields = vortex.volume_interpolant(t, discr)
#rhs_fields = rhs(t, fields)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(visf,
[
("rho", discr.convert_volume(op.rho(fields), kind="numpy")),
("e", discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u", discr.convert_volume(op.rho_u(fields), kind="numpy")),
("u", discr.convert_volume(op.u(fields), kind="numpy")),
#("true_rho", discr.convert_volume(op.rho(true_fields), kind="numpy")),
#("true_e", discr.convert_volume(op.e(true_fields), kind="numpy")),
#("true_rho_u", discr.convert_volume(op.rho_u(true_fields), kind="numpy")),
#("true_u", discr.convert_volume(op.u(true_fields), kind="numpy")),
#("rhs_rho", discr.convert_volume(op.rho(rhs_fields), kind="numpy")),
#("rhs_e", discr.convert_volume(op.e(rhs_fields), kind="numpy")),
#("rhs_rho_u", discr.convert_volume(op.rho_u(rhs_fields), kind="numpy")),
],
expressions=[
#("diff_rho", "rho-true_rho"),
#("diff_e", "e-true_e"),
#("diff_rho_u", "rho_u-true_rho_u", DB_VARTYPE_VECTOR),
("p", "0.4*(e- 0.5*(rho_u*u))"),
],
time=t, step=step
)
visf.close()
fields = stepper(fields, t, dt, rhs)
true_fields = vortex.volume_interpolant(t, discr)
l2_error = discr.norm(fields-true_fields)
l2_error_rho = discr.norm(op.rho(fields)-op.rho(true_fields))
l2_error_e = discr.norm(op.e(fields)-op.e(true_fields))
l2_error_rhou = discr.norm(op.rho_u(fields)-op.rho_u(true_fields))
l2_error_u = discr.norm(op.u(fields)-op.u(true_fields))
eoc_rec.add_data_point(order, l2_error_rho)
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
logmgr.set_constant("l2_error", l2_error)
logmgr.set_constant("l2_error_rho", l2_error_rho)
logmgr.set_constant("l2_error_e", l2_error_e)
logmgr.set_constant("l2_error_rhou", l2_error_rhou)
logmgr.set_constant("l2_error_u", l2_error_u)
logmgr.set_constant("refinement", refine)
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
def main():
from hedge.backends import guess_run_context
rcon = guess_run_context(
#["cuda"]
)
from hedge.tools import EOCRecorder, to_obj_array
eoc_rec = EOCRecorder()
def boundary_tagger(vertices, el, face_nr, all_v):
return ["inflow"]
if rcon.is_head_rank:
from hedge.mesh import make_rect_mesh, \
make_centered_regular_rect_mesh
#mesh = make_rect_mesh((0,0), (10,1), max_area=0.01)
refine = 1
mesh = make_centered_regular_rect_mesh(
(0, 0),
(10, 1),
n=(20, 4),
#periodicity=(True, False),
post_refine_factor=refine,
boundary_tagger=boundary_tagger)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [3]:
discr = rcon.make_discretization(mesh_data,
order=order,
default_scalar_type=numpy.float64)
from hedge.visualization import SiloVisualizer, VtkVisualizer
#vis = VtkVisualizer(discr, rcon, "shearflow-%d" % order)
vis = SiloVisualizer(discr, rcon)
shearflow = SteadyShearFlow()
fields = shearflow.volume_interpolant(0, discr)
gamma, mu, prandtl, spec_gas_const = shearflow.properties()
from hedge.models.gas_dynamics import GasDynamicsOperator
op = GasDynamicsOperator(dimensions=2,
gamma=gamma,
mu=mu,
prandtl=prandtl,
spec_gas_const=spec_gas_const,
bc_inflow=shearflow,
bc_outflow=shearflow,
bc_noslip=shearflow,
inflow_tag="inflow",
outflow_tag="outflow",
noslip_tag="noslip")
navierstokes_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = navierstokes_ex(t, q)
max_eigval[0] = speed
return ode_rhs
# needed to get first estimate of maximum eigenvalue
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
from hedge.timestep import RK4TimeStepper
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
logmgr = LogManager("navierstokes-cpu-%d-%d.dat" % (order, refine),
"w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=0.3,
#max_steps=500,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
for step, t, dt in step_it:
if step % 10 == 0:
#if False:
visf = vis.make_file("shearflow-%d-%04d" % (order, step))
#true_fields = shearflow.volume_interpolant(t, discr)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(
visf,
[
("rho",
discr.convert_volume(op.rho(fields),
kind="numpy")),
("e",
discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u",
discr.convert_volume(op.rho_u(fields),
kind="numpy")),
("u",
discr.convert_volume(op.u(fields), kind="numpy")),
#("true_rho", discr.convert_volume(op.rho(true_fields), kind="numpy")),
#("true_e", discr.convert_volume(op.e(true_fields), kind="numpy")),
#("true_rho_u", discr.convert_volume(op.rho_u(true_fields), kind="numpy")),
#("true_u", discr.convert_volume(op.u(true_fields), kind="numpy")),
],
expressions=[
#("diff_rho", "rho-true_rho"),
#("diff_e", "e-true_e"),
#("diff_rho_u", "rho_u-true_rho_u", DB_VARTYPE_VECTOR),
("p", "0.4*(e- 0.5*(rho_u*u))"),
],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
true_fields = shearflow.volume_interpolant(t, discr)
l2_error = discr.norm(op.u(fields) - op.u(true_fields))
eoc_rec.add_data_point(order, l2_error)
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
logmgr.set_constant("l2_error", l2_error)
finally:
vis.close()
logmgr.save()
discr.close()
def run_convergence_test_advec(dtype,
flux_type,
random_partition,
mesh_gen,
debug_output=False):
"""Test whether 2/3D advection actually converges"""
from hedge.timestep import RK4TimeStepper
from hedge.tools import EOCRecorder
from math import sin
from hedge.data import TimeDependentGivenFunction
from hedge.visualization import SiloVisualizer
from hedge.backends import guess_run_context
rcon = guess_run_context(["mpi"])
# note: x component must remain zero because x-periodicity is used
v = np.array([0.0, 0.9, 0.3])
def f(x):
return sin(x)
def u_analytic(x, el, t):
return f(
(np.dot(-v[:dims], x) / la.norm(v[:dims]) + t * la.norm(v[:dims])))
def boundary_tagger(vertices, el, face_nr, points):
face_normal = el.face_normals[face_nr]
if np.dot(face_normal, v[:len(face_normal)]) < 0:
return ["inflow"]
else:
return ["outflow"]
mesh = mesh_gen(boundary_tagger)
eoc_rec = EOCRecorder()
if random_partition:
# Distribute elements randomly across nodes.
# This is bad, efficiency-wise, but it puts stress
# on the parallel implementation, which is desired here.
# Another main point of this is to force the code to split
# a periodic face pair across nodes.
from random import choice
partition = [choice(rcon.ranks) for el in mesh.elements]
else:
partition = None
for order in [1, 2, 3, 4]:
if rcon.is_head_rank:
mesh_data = rcon.distribute_mesh(mesh, partition)
else:
mesh_data = rcon.receive_mesh()
dims = mesh.points.shape[1]
discr = rcon.make_discretization(mesh_data,
order=order,
default_scalar_type=dtype)
op = StrongAdvectionOperator(
v[:dims],
inflow_u=TimeDependentGivenFunction(u_analytic),
flux_type=flux_type)
if debug_output:
vis = SiloVisualizer(discr, rcon)
u = discr.interpolate_volume_function(
lambda x, el: u_analytic(x, el, 0))
ic = u.copy()
if debug_output and rcon.is_head_rank:
print "#elements=%d" % len(mesh.elements)
test_name = "test-%s-o%d-m%s-r%s" % (
flux_type, order, mesh_gen.__name__, random_partition)
rhs = op.bind(discr)
stepper = RK4TimeStepper(dtype=dtype)
from hedge.timestep import times_and_steps
final_time = 1
step_it = times_and_steps(final_time=final_time,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, fields=u))
for step, t, dt in step_it:
u = stepper(u, t, dt, rhs)
assert u.dtype == dtype
u_true = discr.interpolate_volume_function(
lambda x, el: u_analytic(x, el, final_time))
error = u - u_true
l2_error = discr.norm(error)
if debug_output:
visf = vis.make_file(test_name + "-final")
vis.add_data(visf, [("u", u), ("u_true", u_true), ("ic", ic)])
visf.close()
eoc_rec.add_data_point(order, l2_error)
if debug_output and rcon.is_head_rank:
print "%s\n%s\n" % (flux_type.upper(), "-" * len(flux_type))
print eoc_rec.pretty_print(abscissa_label="Poly. Order",
error_label="L2 Error")
assert eoc_rec.estimate_order_of_convergence()[0, 1] > 3
assert eoc_rec.estimate_order_of_convergence(2)[-1, 1] > 7
def test_convergence_advec_2d():
"""Test whether 2D advection actually converges"""
import pyublas # noqa
from hedge.mesh.generator import make_disk_mesh, make_regular_rect_mesh
from hedge.discretization.local import TriangleDiscretization
from hedge.timestep import RK4TimeStepper
from hedge.tools import EOCRecorder
from math import sin, pi
from hedge.models.advection import StrongAdvectionOperator
from hedge.data import TimeDependentGivenFunction
v = numpy.array([0.27, 0])
norm_a = la.norm(v)
from numpy import dot
def f(x):
return sin(x)
def u_analytic(x, el, t):
return f((-dot(v, x) / norm_a + t * norm_a))
def boundary_tagger(vertices, el, face_nr, all_v):
if dot(el.face_normals[face_nr], v) < 0:
return ["inflow"]
else:
return ["outflow"]
for mesh in [
# non-periodic
make_disk_mesh(r=pi, boundary_tagger=boundary_tagger,
max_area=0.5),
# periodic
make_regular_rect_mesh(
a=(0, 0),
b=(2 * pi, 1),
n=(8, 4),
periodicity=(True, False),
boundary_tagger=boundary_tagger,
)
]:
for flux_type in StrongAdvectionOperator.flux_types:
eoc_rec = EOCRecorder()
for order in [1, 2, 3, 4, 5, 6]:
discr = discr_class(
mesh,
TriangleDiscretization(order),
debug=discr_class.noninteractive_debug_flags())
op = StrongAdvectionOperator(
v,
inflow_u=TimeDependentGivenFunction(u_analytic),
flux_type=flux_type)
u = discr.interpolate_volume_function(
lambda x, el: u_analytic(x, el, 0))
stepper = RK4TimeStepper()
dt = op.estimate_timestep(discr, stepper=stepper)
nsteps = int(1 / dt)
rhs = op.bind(discr)
for step in range(nsteps):
u = stepper(u, step * dt, dt, rhs)
u_true = discr.interpolate_volume_function(
lambda x, el: u_analytic(x, el, nsteps * dt))
error = u - u_true
error_l2 = discr.norm(error)
eoc_rec.add_data_point(order, error_l2)
if False:
print "%s\n%s\n" % (flux_type.upper(), "-" * len(flux_type))
print eoc_rec.pretty_print(abscissa_label="Poly. Order",
error_label="L2 Error")
assert eoc_rec.estimate_order_of_convergence()[0, 1] > 4
assert eoc_rec.estimate_order_of_convergence(2)[-1, 1] > 10
def test_symmetry_preservation_2d():
"""Test whether we preserve symmetry in a symmetric 2D advection problem"""
from numpy import dot
def make_mesh():
array = numpy.array
#
# 1---8---2
# |7 /|\ 1|
# | / | \ |
# |/ 6|0 \|
# 5---4---7
# |\ 5|3 /|
# | \ | / |
# |4 \|/ 2|
# 0---6---3
#
points = [
array([-0.5, -0.5]),
array([-0.5, 0.5]),
array([0.5, 0.5]),
array([0.5, -0.5]),
array([0.0, 0.0]),
array([-0.5, 0.0]),
array([0.0, -0.5]),
array([0.5, 0.0]),
array([0.0, 0.5])
]
elements = [
[8, 7, 4],
[8, 7, 2],
[6, 7, 3],
[7, 4, 6],
[5, 6, 0],
[5, 6, 4],
[5, 8, 4],
[1, 5, 8],
]
def boundary_tagger(vertices, el, face_nr, all_v):
if dot(el.face_normals[face_nr], v) < 0:
return ["inflow"]
else:
return ["outflow"]
from hedge.mesh import make_conformal_mesh
return make_conformal_mesh(points, elements, boundary_tagger)
from hedge.discretization import SymmetryMap
from hedge.timestep import RK4TimeStepper
from hedge.models.advection import StrongAdvectionOperator
from hedge.data import TimeDependentGivenFunction
v = numpy.array([-1, 0])
mesh = make_mesh()
discr = discr_class(mesh,
order=4,
debug=discr_class.noninteractive_debug_flags())
#ref_discr = DynamicDiscretization(mesh, order=4)
def f(x):
if x < 0.5:
return 0
else:
return (x - 0.5)
#def f(x):
#return sin(5*x)
def u_analytic(x, el, t):
return f(-dot(v, x) + t)
u = discr.interpolate_volume_function(lambda x, el: u_analytic(x, el, 0))
sym_map = SymmetryMap(discr, lambda x: numpy.array([x[0], -x[1]]), {
0: 3,
2: 1,
5: 6,
7: 4
})
for flux_type in StrongAdvectionOperator.flux_types:
stepper = RK4TimeStepper()
op = StrongAdvectionOperator(
v,
inflow_u=TimeDependentGivenFunction(u_analytic),
flux_type=flux_type)
dt = op.estimate_timestep(discr, stepper=stepper)
nsteps = int(1 / dt)
rhs = op.bind(discr)
#test_comp = [ "bflux"]
#test_rhs = op.bind(discr, test_comp)
#ref_rhs = op.bind(ref_discr, test_comp)
for step in xrange(nsteps):
u = stepper(u, step * dt, dt, rhs)
sym_error_u = u - sym_map(u)
sym_error_u_l2 = discr.norm(sym_error_u)
if False:
from hedge.visualization import SiloVisualizer
vis = SiloVisualizer(discr)
visf = vis.make_file("test-%s-%04d" % (flux_type, step))
vis.add_data(
visf,
[
("u", u),
("sym_u", sym_map(u)),
("sym_diff", u - sym_map(u)),
("rhs", rhs(step * dt, u)),
#("rhs_test", test_rhs(step*dt, u)),
#("rhs_ref", ref_rhs(step*dt, u)),
#("rhs_diff", test_rhs(step*dt, u)-ref_rhs(step*dt, u)),
])
print sym_error_u_l2
assert sym_error_u_l2 < 4e-15
def main(write_output=True, allow_features=None):
from hedge.timestep import RK4TimeStepper
from hedge.mesh import make_ball_mesh, make_cylinder_mesh, make_box_mesh
from hedge.visualization import \
VtkVisualizer, \
SiloVisualizer, \
get_rank_partition
from math import sqrt, pi
from hedge.backends import guess_run_context
rcon = guess_run_context(allow_features)
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4 * pi * 1e-7 # N/A**2.
epsilon = 1 * epsilon0
mu = 1 * mu0
dims = 3
if rcon.is_head_rank:
if dims == 2:
from hedge.mesh import make_rect_mesh
mesh = make_rect_mesh(a=(-10.5, -1.5), b=(10.5, 1.5), max_area=0.1)
elif dims == 3:
from hedge.mesh import make_box_mesh
mesh = make_box_mesh(a=(-10.5, -1.5, -1.5),
b=(10.5, 1.5, 1.5),
max_volume=0.1)
if rcon.is_head_rank:
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
#for order in [1,2,3,4,5,6]:
discr = rcon.make_discretization(mesh_data, order=3)
if write_output:
vis = VtkVisualizer(discr, rcon, "dipole")
from analytic_solutions import DipoleFarField, SphericalFieldAdapter
from hedge.data import ITimeDependentGivenFunction
sph_dipole = DipoleFarField(
q=1, #C
d=1 / 39,
omega=2 * pi * 1e8,
epsilon=epsilon0,
mu=mu0,
)
cart_dipole = SphericalFieldAdapter(sph_dipole)
class PointDipoleSource(ITimeDependentGivenFunction):
def __init__(self):
from pyrticle.tools import CInfinityShapeFunction
sf = CInfinityShapeFunction(0.1 * sph_dipole.wavelength,
discr.dimensions)
self.num_sf = discr.interpolate_volume_function(
lambda x, el: sf(x))
self.vol_0 = discr.volume_zeros()
def volume_interpolant(self, t, discr):
from hedge.tools import make_obj_array
return make_obj_array([
self.vol_0, self.vol_0,
sph_dipole.source_modulation(t) * self.num_sf
])
from hedge.mesh import TAG_ALL, TAG_NONE
if dims == 2:
from hedge.models.em import TMMaxwellOperator as MaxwellOperator
else:
from hedge.models.em import MaxwellOperator
op = MaxwellOperator(
epsilon,
mu,
flux_type=1,
pec_tag=TAG_NONE,
absorb_tag=TAG_ALL,
current=PointDipoleSource(),
)
fields = op.assemble_eh(discr=discr)
if rcon.is_head_rank:
print "#elements=", len(mesh.elements)
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "dipole.dat"
else:
log_file_name = None
logmgr = LogManager(log_file_name, "w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
from hedge.log import EMFieldGetter, add_em_quantities
field_getter = EMFieldGetter(discr, op, lambda: fields)
add_em_quantities(logmgr, op, field_getter)
from pytools.log import PushLogQuantity
relerr_e_q = PushLogQuantity("relerr_e", "1",
"Relative error in masked E-field")
relerr_h_q = PushLogQuantity("relerr_h", "1",
"Relative error in masked H-field")
logmgr.add_quantity(relerr_e_q)
logmgr.add_quantity(relerr_h_q)
logmgr.add_watches([
"step.max", "t_sim.max", ("W_field", "W_el+W_mag"), "t_step.max",
"relerr_e", "relerr_h"
])
if write_output:
point_timeseries = [(open("b-x%d-vs-time.dat" % i,
"w"), open("b-x%d-vs-time-true.dat" % i,
"w"),
discr.get_point_evaluator(
numpy.array([i, 0, 0][:dims],
dtype=discr.default_scalar_type)))
for i in range(1, 5)]
# timestep loop -------------------------------------------------------
mask = discr.interpolate_volume_function(sph_dipole.far_field_mask)
def apply_mask(field):
from hedge.tools import log_shape
ls = log_shape(field)
result = discr.volume_empty(ls)
from pytools import indices_in_shape
for i in indices_in_shape(ls):
result[i] = mask * field[i]
return result
rhs = op.bind(discr)
t = 0
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=1e-8,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, fields=fields))
for step, t, dt in step_it:
if write_output and step % 10 == 0:
sub_timer = vis_timer.start_sub_timer()
e, h = op.split_eh(fields)
sph_dipole.set_time(t)
true_e, true_h = op.split_eh(
discr.interpolate_volume_function(cart_dipole))
visf = vis.make_file("dipole-%04d" % step)
mask_e = apply_mask(e)
mask_h = apply_mask(h)
mask_true_e = apply_mask(true_e)
mask_true_h = apply_mask(true_h)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(visf, [("e", e), ("h", h), ("true_e", true_e),
("true_h", true_h), ("mask_e", mask_e),
("mask_h", mask_h),
("mask_true_e", mask_true_e),
("mask_true_h", mask_true_h)],
time=t,
step=step)
visf.close()
sub_timer.stop().submit()
from hedge.tools import relative_error
relerr_e_q.push_value(
relative_error(discr.norm(mask_e - mask_true_e),
discr.norm(mask_true_e)))
relerr_h_q.push_value(
relative_error(discr.norm(mask_h - mask_true_h),
discr.norm(mask_true_h)))
if write_output:
for outf_num, outf_true, evaluator in point_timeseries:
for outf, ev_h in zip([outf_num, outf_true],
[h, true_h]):
outf.write("%g\t%g\n" %
(t, op.mu * evaluator(ev_h[1])))
outf.flush()
fields = stepper(fields, t, dt, rhs)
finally:
if write_output:
vis.close()
logmgr.save()
discr.close()
def main():
from hedge.backends import guess_run_context
rcon = guess_run_context(["cuda"])
if rcon.is_head_rank:
mesh = make_boxmesh()
#from hedge.mesh import make_rect_mesh
#mesh = make_rect_mesh(
# boundary_tagger=lambda fvi, el, fn, all_v: ["inflow"])
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [3]:
from pytools import add_python_path_relative_to_script
add_python_path_relative_to_script("..")
from gas_dynamics_initials import UniformMachFlow
box = UniformMachFlow(angle_of_attack=0)
from hedge.models.gas_dynamics import GasDynamicsOperator
op = GasDynamicsOperator(dimensions=3,
gamma=box.gamma,
mu=box.mu,
prandtl=box.prandtl,
spec_gas_const=box.spec_gas_const,
bc_inflow=box,
bc_outflow=box,
bc_noslip=box,
inflow_tag="inflow",
outflow_tag="outflow",
noslip_tag="noslip")
discr = rcon.make_discretization(
mesh_data,
order=order,
debug=[
#"cuda_no_plan",
#"cuda_dump_kernels",
#"dump_dataflow_graph",
#"dump_optemplate_stages",
#"dump_dataflow_graph",
#"print_op_code",
"cuda_no_plan_el_local",
],
default_scalar_type=numpy.float32,
tune_for=op.op_template())
from hedge.visualization import SiloVisualizer, VtkVisualizer # noqa
#vis = VtkVisualizer(discr, rcon, "shearflow-%d" % order)
vis = SiloVisualizer(discr, rcon)
fields = box.volume_interpolant(0, discr)
navierstokes_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = navierstokes_ex(t, q)
max_eigval[0] = speed
return ode_rhs
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
from hedge.timestep import RK4TimeStepper
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
logmgr = LogManager("navierstokes-%d.dat" % order, "w",
rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
from pytools.log import LogQuantity
class ChangeSinceLastStep(LogQuantity):
"""Records the change of a variable between a time step and the previous
one"""
def __init__(self, name="change"):
LogQuantity.__init__(self, name, "1",
"Change since last time step")
self.old_fields = 0
def __call__(self):
result = discr.norm(fields - self.old_fields)
self.old_fields = fields
return result
logmgr.add_quantity(ChangeSinceLastStep())
# timestep loop -------------------------------------------------------
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=200,
#max_steps=500,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
for step, t, dt in step_it:
if step % 200 == 0:
#if False:
visf = vis.make_file("box-%d-%06d" % (order, step))
#rhs_fields = rhs(t, fields)
vis.add_data(
visf,
[
("rho",
discr.convert_volume(op.rho(fields),
kind="numpy")),
("e",
discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u",
discr.convert_volume(op.rho_u(fields),
kind="numpy")),
("u",
discr.convert_volume(op.u(fields), kind="numpy")),
# ("rhs_rho", discr.convert_volume(
# op.rho(rhs_fields), kind="numpy")),
# ("rhs_e", discr.convert_volume(
# op.e(rhs_fields), kind="numpy")),
# ("rhs_rho_u", discr.convert_volume(
# op.rho_u(rhs_fields), kind="numpy")),
],
expressions=[
("p", "(0.4)*(e- 0.5*(rho_u*u))"),
],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
finally:
vis.close()
logmgr.save()
discr.close()
def main():
from hedge.backends import guess_run_context
rcon = guess_run_context(["cuda", "mpi"])
if rcon.is_head_rank:
mesh = make_wingmesh()
#from hedge.mesh import make_rect_mesh
#mesh = make_rect_mesh(
# boundary_tagger=lambda fvi, el, fn, all_v: ["inflow"])
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [3]:
from pytools import add_python_path_relative_to_script
add_python_path_relative_to_script("..")
from gas_dynamics_initials import UniformMachFlow
wing = UniformMachFlow(angle_of_attack=0)
from hedge.models.gas_dynamics import GasDynamicsOperator
op = GasDynamicsOperator(dimensions=3,
gamma=wing.gamma,
mu=wing.mu,
prandtl=wing.prandtl,
spec_gas_const=wing.spec_gas_const,
bc_inflow=wing,
bc_outflow=wing,
bc_noslip=wing,
inflow_tag="inflow",
outflow_tag="outflow",
noslip_tag="noslip")
discr = rcon.make_discretization(
mesh_data,
order=order,
debug=[
"cuda_no_plan",
#"cuda_dump_kernels",
#"dump_dataflow_graph",
#"dump_optemplate_stages",
#"dump_dataflow_graph",
#"print_op_code"
"cuda_no_metis",
],
default_scalar_type=numpy.float64,
tune_for=op.op_template())
from hedge.visualization import SiloVisualizer, VtkVisualizer
#vis = VtkVisualizer(discr, rcon, "shearflow-%d" % order)
vis = SiloVisualizer(discr, rcon)
fields = wing.volume_interpolant(0, discr)
navierstokes_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = navierstokes_ex(t, q)
max_eigval[0] = speed
return ode_rhs
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
from hedge.timestep import RK4TimeStepper
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
logmgr = LogManager("navierstokes-%d.dat" % order, "w",
rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=200,
#max_steps=500,
logmgr=logmgr,
max_dt_getter=lambda t: 0.6 * op.estimate_timestep(
discr, stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
for step, t, dt in step_it:
if step % 200 == 0:
#if False:
visf = vis.make_file("wing-%d-%06d" % (order, step))
#rhs_fields = rhs(t, fields)
from pyvisfile.silo import DB_VARTYPE_VECTOR
from hedge.discretization import ones_on_boundary
vis.add_data(
visf,
[
("rho",
discr.convert_volume(op.rho(fields),
kind="numpy")),
("e",
discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u",
discr.convert_volume(op.rho_u(fields),
kind="numpy")),
("u",
discr.convert_volume(op.u(fields), kind="numpy")),
#("rhs_rho", discr.convert_volume(op.rho(rhs_fields), kind="numpy")),
#("rhs_e", discr.convert_volume(op.e(rhs_fields), kind="numpy")),
#("rhs_rho_u", discr.convert_volume(op.rho_u(rhs_fields), kind="numpy")),
],
expressions=[
("p", "(0.4)*(e- 0.5*(rho_u*u))"),
],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
t += dt
finally:
vis.close()
logmgr.save()
discr.close()