def main(): from grudge.backends import guess_run_context rcon = guess_run_context(["cuda"]) if rcon.is_head_rank: mesh = make_boxmesh() #from grudge.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 grudge.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.sym_operator()) from grudge.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 grudge.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 grudge.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 grudge.backends import guess_run_context rcon = guess_run_context(["cuda", "mpi"]) if rcon.is_head_rank: mesh = make_wingmesh() #from grudge.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 grudge.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.sym_operator()) from grudge.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 grudge.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 grudge.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 grudge.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()
def main(write_output=True, allow_features=None): from grudge.timestep import RK4TimeStepper from grudge.mesh import make_ball_mesh, make_cylinder_mesh, make_box_mesh from grudge.visualization import \ VtkVisualizer, \ SiloVisualizer, \ get_rank_partition from math import sqrt, pi from grudge.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 grudge.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 grudge.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 grudge.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 grudge.tools import make_obj_array return make_obj_array([ self.vol_0, self.vol_0, sph_dipole.source_modulation(t) * self.num_sf ]) from grudge.mesh import BTAG_ALL, BTAG_NONE if dims == 2: from grudge.models.em import TMMaxwellOperator as MaxwellOperator else: from grudge.models.em import MaxwellOperator op = MaxwellOperator( epsilon, mu, flux_type=1, pec_tag=BTAG_NONE, absorb_tag=BTAG_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 grudge.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 grudge.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 grudge.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 grudge.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"] ) 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 main(): import logging logging.basicConfig(level=logging.INFO) from grudge.backends import guess_run_context rcon = guess_run_context() if rcon.is_head_rank: if True: mesh = make_squaremesh() else: from grudge.mesh import make_rect_mesh mesh = make_rect_mesh( boundary_tagger=lambda fvi, el, fn, all_v: ["inflow"], max_area=0.1) mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() from pytools import add_python_path_relative_to_script add_python_path_relative_to_script(".") for order in [3]: from gas_dynamics_initials import UniformMachFlow square = UniformMachFlow(gaussian_pulse_at=numpy.array([-2, 2]), pulse_magnitude=0.003) from grudge.models.gas_dynamics import (GasDynamicsOperator, GammaLawEOS) op = GasDynamicsOperator(dimensions=2, equation_of_state=GammaLawEOS(square.gamma), mu=square.mu, prandtl=square.prandtl, spec_gas_const=square.spec_gas_const, bc_inflow=square, bc_outflow=square, bc_noslip=square, 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", #"dump_op_code" #"cuda_no_plan_el_local" ], default_scalar_type=numpy.float64, tune_for=op.sym_operator(), quad_min_degrees={ "gasdyn_vol": 3 * order, "gasdyn_face": 3 * order, }) from grudge.visualization import SiloVisualizer, VtkVisualizer #vis = VtkVisualizer(discr, rcon, "shearflow-%d" % order) vis = SiloVisualizer(discr, rcon) from grudge.timestep.runge_kutta import (LSRK4TimeStepper, ODE23TimeStepper, ODE45TimeStepper) from grudge.timestep.dumka3 import Dumka3TimeStepper #stepper = LSRK4TimeStepper(dtype=discr.default_scalar_type, #vector_primitive_factory=discr.get_vector_primitive_factory()) stepper = ODE23TimeStepper( dtype=discr.default_scalar_type, rtol=1e-6, vector_primitive_factory=discr.get_vector_primitive_factory()) # Dumka works kind of poorly #stepper = Dumka3TimeStepper(dtype=discr.default_scalar_type, #rtol=1e-7, pol_index=2, #vector_primitive_factory=discr.get_vector_primitive_factory()) #from grudge.timestep.dumka3 import Dumka3TimeStepper #stepper = Dumka3TimeStepper(3, rtol=1e-7) # diagnostics setup --------------------------------------------------- from pytools.log import LogManager, add_general_quantities, \ add_simulation_quantities, add_run_info logmgr = LogManager("cns-square-sp-%d.dat" % order, "w", rcon.communicator) add_run_info(logmgr) add_general_quantities(logmgr) discr.add_instrumentation(logmgr) stepper.add_instrumentation(logmgr) 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()) add_simulation_quantities(logmgr) logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"]) # filter setup ------------------------------------------------------------ from grudge.discretization import Filter, ExponentialFilterResponseFunction mode_filter = Filter( discr, ExponentialFilterResponseFunction(min_amplification=0.95, order=6)) # timestep loop ------------------------------------------------------- fields = square.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)) try: from grudge.timestep import times_and_steps step_it = times_and_steps( final_time=1000, #max_steps=500, logmgr=logmgr, max_dt_getter=lambda t: next_dt, taken_dt_getter=lambda: taken_dt) model_stepper = LSRK4TimeStepper() next_dt = op.estimate_timestep(discr, stepper=model_stepper, t=0, max_eigenvalue=max_eigval[0]) for step, t, dt in step_it: #if (step % 10000 == 0): #and step < 950000) or (step % 500 == 0 and step > 950000): #if False: if step % 5 == 0: visf = vis.make_file("square-%d-%06d" % (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")), ], expressions=[ ("p", "(0.4)*(e- 0.5*(rho_u*u))"), ], time=t, step=step) visf.close() if stepper.adaptive: fields, t, taken_dt, next_dt = stepper(fields, t, dt, rhs) else: taken_dt = dt fields = stepper(fields, t, dt, rhs) dt = op.estimate_timestep(discr, stepper=model_stepper, t=0, max_eigenvalue=max_eigval[0]) #fields = mode_filter(fields) 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()
extra_fields = [] visf = vis.make_file("fld-%04d" % step) vis.add_data(visf, [ ("u", u), ] + extra_fields, time=t, step=step) visf.close() u = stepper(u, t, dt, rhs) if isinstance(case, ExactTestCase): assert discr.norm(u, 1) < 50 finally: if write_output: vis.close() logmgr.save() if __name__ == "__main__": main() # entry points for py.test ---------------------------------------------------- @mark_test.long def test_stability(): main(write_output=False)
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 main(): from grudge.backends import guess_run_context rcon = guess_run_context() if rcon.is_head_rank: mesh = make_nacamesh() mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() from pytools import add_python_path_relative_to_script add_python_path_relative_to_script("..") for order in [4]: from gas_dynamics_initials import UniformMachFlow uniform_flow = UniformMachFlow() from grudge.models.gas_dynamics import GasDynamicsOperator, GammaLawEOS op = GasDynamicsOperator(dimensions=2, equation_of_state=GammaLawEOS( uniform_flow.gamma), prandtl=uniform_flow.prandtl, spec_gas_const=uniform_flow.spec_gas_const, mu=uniform_flow.mu, bc_inflow=uniform_flow, bc_outflow=uniform_flow, bc_noslip=uniform_flow, 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_optemplate_stages", #"dump_dataflow_graph", #"print_op_code" ], default_scalar_type=numpy.float32, tune_for=op.sym_operator()) from grudge.visualization import SiloVisualizer, VtkVisualizer #vis = VtkVisualizer(discr, rcon, "shearflow-%d" % order) vis = SiloVisualizer(discr, rcon) fields = uniform_flow.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 grudge.timestep.runge_kutta import \ ODE23TimeStepper, LSRK4TimeStepper stepper = ODE23TimeStepper( dtype=discr.default_scalar_type, rtol=1e-6, vector_primitive_factory=discr.get_vector_primitive_factory()) #stepper = LSRK4TimeStepper(dtype=discr.default_scalar_type) # diagnostics setup --------------------------------------------------- from pytools.log import LogManager, add_general_quantities, \ add_simulation_quantities, add_run_info logmgr = LogManager("cns-naca-%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) 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()) # filter setup------------------------------------------------------------- from grudge.discretization import Filter, ExponentialFilterResponseFunction mode_filter = Filter( discr, ExponentialFilterResponseFunction(min_amplification=0.9, order=4)) # timestep loop ------------------------------------------------------- logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"]) try: from grudge.timestep import times_and_steps step_it = times_and_steps( final_time=200, #max_steps=500, logmgr=logmgr, max_dt_getter=lambda t: next_dt, taken_dt_getter=lambda: taken_dt) model_stepper = LSRK4TimeStepper() next_dt = op.estimate_timestep(discr, stepper=model_stepper, t=0, max_eigenvalue=max_eigval[0]) for step, t, dt in step_it: if step % 10 == 0: visf = vis.make_file("naca-%d-%06d" % (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", 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, t, taken_dt, next_dt = stepper(fields, t, dt, rhs) fields = mode_filter(fields) finally: vis.close() logmgr.save() discr.close()
def main(write_output=True, flux_type_arg="upwind", #case = CenteredStationaryTestCase(), #case = OffCenterStationaryTestCase(), #case = OffCenterMigratingTestCase(), case = ExactTestCase(), ): from hedge.backends import guess_run_context rcon = guess_run_context() order = 3 if rcon.is_head_rank: if True: from hedge.mesh.generator import make_uniform_1d_mesh mesh = make_uniform_1d_mesh(case.a, case.b, 20, periodic=True) else: from hedge.mesh.generator import make_rect_mesh print (pi*2)/(11*5*2) mesh = make_rect_mesh((-pi, -1), (pi, 1), periodicity=(True, True), subdivisions=(11,5), max_area=(pi*2)/(11*5*2) ) if rcon.is_head_rank: mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() discr = rcon.make_discretization(mesh_data, order=order, quad_min_degrees={"quad": 3*order}) if write_output: from hedge.visualization import VtkVisualizer vis = VtkVisualizer(discr, rcon, "fld") # operator setup ---------------------------------------------------------- from hedge.second_order import IPDGSecondDerivative from hedge.models.burgers import BurgersOperator op = BurgersOperator(mesh.dimensions, viscosity_scheme=IPDGSecondDerivative()) if rcon.is_head_rank: print "%d elements" % len(discr.mesh.elements) # exact solution ---------------------------------------------------------- import pymbolic var = pymbolic.var u = discr.interpolate_volume_function(lambda x, el: case.u0(x[0])) # diagnostics setup ------------------------------------------------------- from pytools.log import LogManager, \ add_general_quantities, \ add_simulation_quantities, \ add_run_info if write_output: log_file_name = "burgers.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) from hedge.log import LpNorm u_getter = lambda: u logmgr.add_quantity(LpNorm(u_getter, discr, p=1, name="l1_u")) logmgr.add_watches(["step.max", "t_sim.max", "l1_u", "t_step.max"]) # timestep loop ----------------------------------------------------------- rhs = op.bind(discr) from hedge.timestep.runge_kutta import ODE45TimeStepper, LSRK4TimeStepper stepper = ODE45TimeStepper() stepper.add_instrumentation(logmgr) try: from hedge.timestep import times_and_steps # for visc=0.01 #stab_fac = 0.1 # RK4 #stab_fac = 1.6 # dumka3(3), central #stab_fac = 3 # dumka3(4), central #stab_fac = 0.01 # RK4 stab_fac = 0.2 # dumka3(3), central #stab_fac = 3 # dumka3(4), central dt = stab_fac*op.estimate_timestep(discr, stepper=LSRK4TimeStepper(), t=0, fields=u) step_it = times_and_steps( final_time=case.final_time, logmgr=logmgr, max_dt_getter=lambda t: dt) from hedge.optemplate import InverseVandermondeOperator inv_vdm = InverseVandermondeOperator().bind(discr) for step, t, dt in step_it: if step % 3 == 0 and write_output: if hasattr(case, "u_exact"): extra_fields = [ ("u_exact", discr.interpolate_volume_function( lambda x, el: case.u_exact(x[0], t)))] else: extra_fields = [] visf = vis.make_file("fld-%04d" % step) vis.add_data(visf, [ ("u", u), ] + extra_fields, time=t, step=step) visf.close() u = stepper(u, t, dt, rhs) if isinstance(case, ExactTestCase): assert discr.norm(u, 1) < 50 finally: if write_output: vis.close() logmgr.save()
class PICRunner(object): def __init__(self): from pyrticle.units import SIUnitsWithNaturalConstants self.units = units = SIUnitsWithNaturalConstants() ui = PICCPyUserInterface(units) setup = self.setup = ui.gather() from pytools.log import LogManager import os.path self.logmgr = LogManager(os.path.join( setup.output_path, "pic.dat"), "w") from hedge.backends import guess_run_context self.rcon = guess_run_context([]) if self.rcon.is_head_rank: mesh = self.rcon.distribute_mesh(setup.mesh) else: mesh = self.rcon.receive_mesh() self.discr = discr = \ self.rcon.make_discretization(mesh, order=setup.element_order, debug=setup.dg_debug) self.logmgr.set_constant("elements_total", len(setup.mesh.elements)) self.logmgr.set_constant("elements_local", len(mesh.elements)) self.logmgr.set_constant("element_order", setup.element_order) # em operator --------------------------------------------------------- maxwell_kwargs = { "epsilon": units.EPSILON0, "mu": units.MU0, "flux_type": setup.maxwell_flux_type, "bdry_flux_type": setup.maxwell_bdry_flux_type } if discr.dimensions == 3: from hedge.models.em import MaxwellOperator self.maxwell_op = MaxwellOperator(**maxwell_kwargs) elif discr.dimensions == 2: from hedge.models.em import TEMaxwellOperator self.maxwell_op = TEMaxwellOperator(**maxwell_kwargs) else: raise ValueError, "invalid mesh dimension" if setup.chi is not None: from pyrticle.hyperbolic import ECleaningMaxwellOperator self.maxwell_op = ECleaningMaxwellOperator(self.maxwell_op, chi=setup.chi, phi_decay=setup.phi_decay) if setup.phi_filter is not None: from pyrticle.hyperbolic import PhiFilter from hedge.discretization import Filter, ExponentialFilterResponseFunction em_filters.append( PhiFilter(maxwell_op, Filter(discr, ExponentialFilterResponseFunction(*setup.phi_filter)))) # timestepping setup -------------------------------------------------- goal_dt = self.maxwell_op.estimate_timestep(discr) * setup.dt_scale self.nsteps = int(setup.final_time/goal_dt)+1 self.dt = setup.final_time/self.nsteps self.stepper = setup.timestepper_maker(self.dt) # particle setup ------------------------------------------------------ from pyrticle.cloud import PicMethod, PicState, \ optimize_shape_bandwidth, \ guess_shape_bandwidth method = self.method = PicMethod(discr, units, setup.depositor, setup.pusher, dimensions_pos=setup.dimensions_pos, dimensions_velocity=setup.dimensions_velocity, debug=setup.debug) self.state = method.make_state() method.add_particles( self.state, setup.distribution.generate_particles(), setup.nparticles) self.total_charge = setup.nparticles*setup.distribution.mean()[2][0] if isinstance(setup.shape_bandwidth, str): if setup.shape_bandwidth == "optimize": optimize_shape_bandwidth(method, self.state, setup.distribution.get_rho_interpolant( discr, self.total_charge), setup.shape_exponent) elif setup.shape_bandwidth == "guess": guess_shape_bandwidth(method, self.state, setup.shape_exponent) else: raise ValueError, "invalid shape bandwidth setting '%s'" % ( setup.shape_bandwidth) else: from pyrticle._internal import PolynomialShapeFunction method.depositor.set_shape_function( self.state, PolynomialShapeFunction( float(setup.shape_bandwidth), method.mesh_data.dimensions, setup.shape_exponent, )) # initial condition --------------------------------------------------- if "no_ic" in setup.debug: self.fields = self.maxwell_op.assemble_eh(discr=discr) else: from pyrticle.cloud import compute_initial_condition self.fields = compute_initial_condition(self.rcon, discr, method, self.state, maxwell_op=self.maxwell_op, potential_bc=setup.potential_bc, force_zero=False) # rhs calculators ----------------------------------------------------- from pyrticle.cloud import \ FieldRhsCalculator, \ FieldToParticleRhsCalculator, \ ParticleRhsCalculator, \ ParticleToFieldRhsCalculator self.f_rhs_calculator = FieldRhsCalculator(self.method, self.maxwell_op) self.p_rhs_calculator = ParticleRhsCalculator(self.method, self.maxwell_op) self.f2p_rhs_calculator = FieldToParticleRhsCalculator(self.method, self.maxwell_op) self.p2f_rhs_calculator = ParticleToFieldRhsCalculator(self.method, self.maxwell_op) # instrumentation setup ----------------------------------------------- self.add_instrumentation(self.logmgr) def add_instrumentation(self, logmgr): from pytools.log import \ add_simulation_quantities, \ add_general_quantities, \ add_run_info, ETA from pyrticle.log import add_particle_quantities, add_field_quantities, \ add_beam_quantities, add_currents setup = self.setup from pyrticle.log import StateObserver self.observer = StateObserver(self.method, self.maxwell_op) self.observer.set_fields_and_state(self.fields, self.state) add_run_info(logmgr) add_general_quantities(logmgr) add_simulation_quantities(logmgr) add_particle_quantities(logmgr, self.observer) add_field_quantities(logmgr, self.observer) if setup.beam_axis is not None and setup.beam_diag_axis is not None: add_beam_quantities(logmgr, self.observer, axis=setup.beam_diag_axis, beam_axis=setup.beam_axis) if setup.tube_length is not None: from hedge.tools import unit_vector add_currents(logmgr, self.observer, unit_vector(self.method.dimensions_velocity, setup.beam_axis), setup.tube_length) self.method.add_instrumentation(logmgr, self.observer) self.f_rhs_calculator.add_instrumentation(logmgr) if hasattr(self.stepper, "add_instrumentation"): self.stepper.add_instrumentation(logmgr) mean_beta = self.method.mean_beta(self.state) gamma = self.method.units.gamma_from_beta(mean_beta) logmgr.set_constant("dt", self.dt) logmgr.set_constant("beta", mean_beta) logmgr.set_constant("gamma", gamma) logmgr.set_constant("v", mean_beta*self.units.VACUUM_LIGHT_SPEED()) logmgr.set_constant("Q0", self.total_charge) logmgr.set_constant("n_part_0", setup.nparticles) logmgr.set_constant("pmass", setup.distribution.mean()[3][0]) logmgr.set_constant("chi", setup.chi) logmgr.set_constant("phi_decay", setup.phi_decay) logmgr.set_constant("shape_radius_setup", setup.shape_bandwidth) logmgr.set_constant("shape_radius", self.method.depositor.shape_function.radius) logmgr.set_constant("shape_exponent", self.method.depositor.shape_function.exponent) from pytools.log import IntervalTimer self.vis_timer = IntervalTimer("t_vis", "Time spent visualizing") logmgr.add_quantity(self.vis_timer) logmgr.add_quantity(ETA(self.nsteps)) logmgr.add_watches(setup.watch_vars) def inner_run(self): t = 0 setup = self.setup setup.hook_startup(self) vis_order = setup.vis_order if vis_order is None: vis_order = setup.element_order if vis_order != setup.element_order: vis_discr = self.rcon.make_discretization(self.discr.mesh, order=vis_order, debug=setup.dg_debug) from hedge.discretization import Projector vis_proj = Projector(self.discr, vis_discr) else: vis_discr = self.discr def vis_proj(f): return f from hedge.visualization import SiloVisualizer vis = SiloVisualizer(vis_discr) fields = self.fields self.observer.set_fields_and_state(fields, self.state) from hedge.tools import make_obj_array from pyrticle.cloud import TimesteppablePicState def visualize(observer): sub_timer = self.vis_timer.start_sub_timer() import os.path visf = vis.make_file(os.path.join( setup.output_path, setup.vis_pattern % step)) self.method.add_to_vis(vis, visf, observer.state, time=t, step=step) vis.add_data(visf, [(name, vis_proj(fld)) for name, fld in setup.hook_vis_quantities(observer)], time=t, step=step) setup.hook_visualize(self, vis, visf, observer) visf.close() sub_timer.stop().submit() from hedge.timestep.multirate_ab import TwoRateAdamsBashforthTimeStepper if not isinstance(self.stepper, TwoRateAdamsBashforthTimeStepper): def rhs(t, fields_and_state): fields, ts_state = fields_and_state state_f = lambda: ts_state.state fields_f = lambda: fields fields_rhs = ( self.f_rhs_calculator(t, fields_f, state_f) + self.p2f_rhs_calculator(t, fields_f, state_f)) state_rhs = ( self.p_rhs_calculator(t, fields_f, state_f) + self.f2p_rhs_calculator(t, fields_f, state_f)) return make_obj_array([fields_rhs, state_rhs]) step_args = (self.dt, rhs) else: def add_unwrap(rhs): def unwrapping_rhs(t, fields, ts_state): return rhs(t, fields, lambda: ts_state().state) return unwrapping_rhs step_args = (( add_unwrap(self.f_rhs_calculator), add_unwrap(self.p2f_rhs_calculator), add_unwrap(self.f2p_rhs_calculator), add_unwrap(self.p_rhs_calculator), ),) y = make_obj_array([ fields, TimesteppablePicState(self.method, self.state) ]) del self.state try: from hedge.timestep import times_and_steps step_it = times_and_steps( max_steps=self.nsteps, logmgr=self.logmgr, max_dt_getter=lambda t: self.dt) for step, t, dt in step_it: self.method.upkeep(y[1].state) if step % setup.vis_interval == 0: visualize(self.observer) y = self.stepper(y, t, *step_args) fields, ts_state = y self.observer.set_fields_and_state(fields, ts_state.state) setup.hook_after_step(self, self.observer) finally: vis.close() self.discr.close() self.logmgr.save() setup.hook_when_done(self) def run(self): if self.setup.profile_output_filename is not None: from cProfile import Profile prof = Profile() try: prof.runcall(self.inner_run) finally: from lsprofcalltree import KCacheGrind kg = KCacheGrind(prof) kg.output(open(self.setup.profile_output_filename, "w")) else: self.inner_run()
def main(): import logging logging.basicConfig(level=logging.INFO) from hedge.backends import guess_run_context rcon = guess_run_context() if rcon.is_head_rank: if True: mesh = make_squaremesh() else: from hedge.mesh import make_rect_mesh mesh = make_rect_mesh( boundary_tagger=lambda fvi, el, fn, all_v: ["inflow"], max_area=0.1) mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() from pytools import add_python_path_relative_to_script add_python_path_relative_to_script(".") for order in [3]: from gas_dynamics_initials import UniformMachFlow square = UniformMachFlow(gaussian_pulse_at=numpy.array([-2, 2]), pulse_magnitude=0.003) from hedge.models.gas_dynamics import ( GasDynamicsOperator, GammaLawEOS) op = GasDynamicsOperator(dimensions=2, equation_of_state=GammaLawEOS(square.gamma), mu=square.mu, prandtl=square.prandtl, spec_gas_const=square.spec_gas_const, bc_inflow=square, bc_outflow=square, bc_noslip=square, 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", #"dump_op_code" #"cuda_no_plan_el_local" ], default_scalar_type=numpy.float64, tune_for=op.op_template(), quad_min_degrees={ "gasdyn_vol": 3*order, "gasdyn_face": 3*order, } ) from hedge.visualization import SiloVisualizer, VtkVisualizer #vis = VtkVisualizer(discr, rcon, "shearflow-%d" % order) vis = SiloVisualizer(discr, rcon) from hedge.timestep.runge_kutta import ( LSRK4TimeStepper, ODE23TimeStepper, ODE45TimeStepper) from hedge.timestep.dumka3 import Dumka3TimeStepper #stepper = LSRK4TimeStepper(dtype=discr.default_scalar_type, #vector_primitive_factory=discr.get_vector_primitive_factory()) stepper = ODE23TimeStepper(dtype=discr.default_scalar_type, rtol=1e-6, vector_primitive_factory=discr.get_vector_primitive_factory()) # Dumka works kind of poorly #stepper = Dumka3TimeStepper(dtype=discr.default_scalar_type, #rtol=1e-7, pol_index=2, #vector_primitive_factory=discr.get_vector_primitive_factory()) #from hedge.timestep.dumka3 import Dumka3TimeStepper #stepper = Dumka3TimeStepper(3, rtol=1e-7) # diagnostics setup --------------------------------------------------- from pytools.log import LogManager, add_general_quantities, \ add_simulation_quantities, add_run_info logmgr = LogManager("cns-square-sp-%d.dat" % order, "w", rcon.communicator) add_run_info(logmgr) add_general_quantities(logmgr) discr.add_instrumentation(logmgr) stepper.add_instrumentation(logmgr) 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()) add_simulation_quantities(logmgr) logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"]) # filter setup ------------------------------------------------------------ from hedge.discretization import Filter, ExponentialFilterResponseFunction mode_filter = Filter(discr, ExponentialFilterResponseFunction(min_amplification=0.95, order=6)) # timestep loop ------------------------------------------------------- fields = square.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) try: from hedge.timestep import times_and_steps step_it = times_and_steps( final_time=1000, #max_steps=500, logmgr=logmgr, max_dt_getter=lambda t: next_dt, taken_dt_getter=lambda: taken_dt) model_stepper = LSRK4TimeStepper() next_dt = op.estimate_timestep(discr, stepper=model_stepper, t=0, max_eigenvalue=max_eigval[0]) for step, t, dt in step_it: #if (step % 10000 == 0): #and step < 950000) or (step % 500 == 0 and step > 950000): #if False: if step % 5 == 0: visf = vis.make_file("square-%d-%06d" % (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")), ], expressions=[ ("p", "(0.4)*(e- 0.5*(rho_u*u))"), ], time=t, step=step ) visf.close() if stepper.adaptive: fields, t, taken_dt, next_dt = stepper(fields, t, dt, rhs) else: taken_dt = dt fields = stepper(fields, t, dt, rhs) dt = op.estimate_timestep(discr, stepper=model_stepper, t=0, max_eigenvalue=max_eigval[0]) #fields = mode_filter(fields) finally: vis.close() logmgr.save() discr.close()
def main(): from hedge.backends import guess_run_context rcon = guess_run_context() if rcon.is_head_rank: mesh = make_nacamesh() mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() from pytools import add_python_path_relative_to_script add_python_path_relative_to_script("..") for order in [4]: from gas_dynamics_initials import UniformMachFlow uniform_flow = UniformMachFlow() from hedge.models.gas_dynamics import GasDynamicsOperator, GammaLawEOS op = GasDynamicsOperator( dimensions=2, equation_of_state=GammaLawEOS(uniform_flow.gamma), prandtl=uniform_flow.prandtl, spec_gas_const=uniform_flow.spec_gas_const, mu=uniform_flow.mu, bc_inflow=uniform_flow, bc_outflow=uniform_flow, bc_noslip=uniform_flow, 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_optemplate_stages", # "dump_dataflow_graph", # "print_op_code" ], default_scalar_type=numpy.float32, tune_for=op.op_template(), ) from hedge.visualization import SiloVisualizer, VtkVisualizer # vis = VtkVisualizer(discr, rcon, "shearflow-%d" % order) vis = SiloVisualizer(discr, rcon) fields = uniform_flow.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.runge_kutta import ODE23TimeStepper, LSRK4TimeStepper stepper = ODE23TimeStepper( dtype=discr.default_scalar_type, rtol=1e-6, vector_primitive_factory=discr.get_vector_primitive_factory() ) # stepper = LSRK4TimeStepper(dtype=discr.default_scalar_type) # diagnostics setup --------------------------------------------------- from pytools.log import LogManager, add_general_quantities, add_simulation_quantities, add_run_info logmgr = LogManager("cns-naca-%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) 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()) # filter setup------------------------------------------------------------- from hedge.discretization import Filter, ExponentialFilterResponseFunction mode_filter = Filter(discr, ExponentialFilterResponseFunction(min_amplification=0.9, order=4)) # timestep loop ------------------------------------------------------- logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"]) 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: next_dt, taken_dt_getter=lambda: taken_dt, ) model_stepper = LSRK4TimeStepper() next_dt = op.estimate_timestep(discr, stepper=model_stepper, t=0, max_eigenvalue=max_eigval[0]) for step, t, dt in step_it: if step % 10 == 0: visf = vis.make_file("naca-%d-%06d" % (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", 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, t, taken_dt, next_dt = stepper(fields, t, dt, rhs) fields = mode_filter(fields) finally: vis.close() logmgr.save() discr.close()
class PICRunner(object): def __init__(self): from pyrticle.units import SIUnitsWithNaturalConstants self.units = units = SIUnitsWithNaturalConstants() ui = PICCPyUserInterface(units) setup = self.setup = ui.gather() from pytools.log import LogManager import os.path self.logmgr = LogManager(os.path.join(setup.output_path, "pic.dat"), "w") from hedge.backends import guess_run_context self.rcon = guess_run_context([]) if self.rcon.is_head_rank: mesh = self.rcon.distribute_mesh(setup.mesh) else: mesh = self.rcon.receive_mesh() self.discr = discr = \ self.rcon.make_discretization(mesh, order=setup.element_order, debug=setup.dg_debug) self.logmgr.set_constant("elements_total", len(setup.mesh.elements)) self.logmgr.set_constant("elements_local", len(mesh.elements)) self.logmgr.set_constant("element_order", setup.element_order) # em operator --------------------------------------------------------- maxwell_kwargs = { "epsilon": units.EPSILON0, "mu": units.MU0, "flux_type": setup.maxwell_flux_type, "bdry_flux_type": setup.maxwell_bdry_flux_type } if discr.dimensions == 3: from hedge.models.em import MaxwellOperator self.maxwell_op = MaxwellOperator(**maxwell_kwargs) elif discr.dimensions == 2: from hedge.models.em import TEMaxwellOperator self.maxwell_op = TEMaxwellOperator(**maxwell_kwargs) else: raise ValueError, "invalid mesh dimension" if setup.chi is not None: from pyrticle.hyperbolic import ECleaningMaxwellOperator self.maxwell_op = ECleaningMaxwellOperator( self.maxwell_op, chi=setup.chi, phi_decay=setup.phi_decay) if setup.phi_filter is not None: from pyrticle.hyperbolic import PhiFilter from hedge.discretization import Filter, ExponentialFilterResponseFunction em_filters.append( PhiFilter( maxwell_op, Filter( discr, ExponentialFilterResponseFunction( *setup.phi_filter)))) # timestepping setup -------------------------------------------------- goal_dt = self.maxwell_op.estimate_timestep(discr) * setup.dt_scale self.nsteps = int(setup.final_time / goal_dt) + 1 self.dt = setup.final_time / self.nsteps self.stepper = setup.timestepper_maker(self.dt) # particle setup ------------------------------------------------------ from pyrticle.cloud import PicMethod, PicState, \ optimize_shape_bandwidth, \ guess_shape_bandwidth method = self.method = PicMethod( discr, units, setup.depositor, setup.pusher, dimensions_pos=setup.dimensions_pos, dimensions_velocity=setup.dimensions_velocity, debug=setup.debug) self.state = method.make_state() method.add_particles(self.state, setup.distribution.generate_particles(), setup.nparticles) self.total_charge = setup.nparticles * setup.distribution.mean()[2][0] if isinstance(setup.shape_bandwidth, str): if setup.shape_bandwidth == "optimize": optimize_shape_bandwidth( method, self.state, setup.distribution.get_rho_interpolant( discr, self.total_charge), setup.shape_exponent) elif setup.shape_bandwidth == "guess": guess_shape_bandwidth(method, self.state, setup.shape_exponent) else: raise ValueError, "invalid shape bandwidth setting '%s'" % ( setup.shape_bandwidth) else: from pyrticle._internal import PolynomialShapeFunction method.depositor.set_shape_function( self.state, PolynomialShapeFunction( float(setup.shape_bandwidth), method.mesh_data.dimensions, setup.shape_exponent, )) # initial condition --------------------------------------------------- if "no_ic" in setup.debug: self.fields = self.maxwell_op.assemble_eh(discr=discr) else: from pyrticle.cloud import compute_initial_condition self.fields = compute_initial_condition( self.rcon, discr, method, self.state, maxwell_op=self.maxwell_op, potential_bc=setup.potential_bc, force_zero=False) # rhs calculators ----------------------------------------------------- from pyrticle.cloud import \ FieldRhsCalculator, \ FieldToParticleRhsCalculator, \ ParticleRhsCalculator, \ ParticleToFieldRhsCalculator self.f_rhs_calculator = FieldRhsCalculator(self.method, self.maxwell_op) self.p_rhs_calculator = ParticleRhsCalculator(self.method, self.maxwell_op) self.f2p_rhs_calculator = FieldToParticleRhsCalculator( self.method, self.maxwell_op) self.p2f_rhs_calculator = ParticleToFieldRhsCalculator( self.method, self.maxwell_op) # instrumentation setup ----------------------------------------------- self.add_instrumentation(self.logmgr) def add_instrumentation(self, logmgr): from pytools.log import \ add_simulation_quantities, \ add_general_quantities, \ add_run_info, ETA from pyrticle.log import add_particle_quantities, add_field_quantities, \ add_beam_quantities, add_currents setup = self.setup from pyrticle.log import StateObserver self.observer = StateObserver(self.method, self.maxwell_op) self.observer.set_fields_and_state(self.fields, self.state) add_run_info(logmgr) add_general_quantities(logmgr) add_simulation_quantities(logmgr) add_particle_quantities(logmgr, self.observer) add_field_quantities(logmgr, self.observer) if setup.beam_axis is not None and setup.beam_diag_axis is not None: add_beam_quantities(logmgr, self.observer, axis=setup.beam_diag_axis, beam_axis=setup.beam_axis) if setup.tube_length is not None: from hedge.tools import unit_vector add_currents( logmgr, self.observer, unit_vector(self.method.dimensions_velocity, setup.beam_axis), setup.tube_length) self.method.add_instrumentation(logmgr, self.observer) self.f_rhs_calculator.add_instrumentation(logmgr) if hasattr(self.stepper, "add_instrumentation"): self.stepper.add_instrumentation(logmgr) mean_beta = self.method.mean_beta(self.state) gamma = self.method.units.gamma_from_beta(mean_beta) logmgr.set_constant("dt", self.dt) logmgr.set_constant("beta", mean_beta) logmgr.set_constant("gamma", gamma) logmgr.set_constant("v", mean_beta * self.units.VACUUM_LIGHT_SPEED()) logmgr.set_constant("Q0", self.total_charge) logmgr.set_constant("n_part_0", setup.nparticles) logmgr.set_constant("pmass", setup.distribution.mean()[3][0]) logmgr.set_constant("chi", setup.chi) logmgr.set_constant("phi_decay", setup.phi_decay) logmgr.set_constant("shape_radius_setup", setup.shape_bandwidth) logmgr.set_constant("shape_radius", self.method.depositor.shape_function.radius) logmgr.set_constant("shape_exponent", self.method.depositor.shape_function.exponent) from pytools.log import IntervalTimer self.vis_timer = IntervalTimer("t_vis", "Time spent visualizing") logmgr.add_quantity(self.vis_timer) logmgr.add_quantity(ETA(self.nsteps)) logmgr.add_watches(setup.watch_vars) def inner_run(self): t = 0 setup = self.setup setup.hook_startup(self) vis_order = setup.vis_order if vis_order is None: vis_order = setup.element_order if vis_order != setup.element_order: vis_discr = self.rcon.make_discretization(self.discr.mesh, order=vis_order, debug=setup.dg_debug) from hedge.discretization import Projector vis_proj = Projector(self.discr, vis_discr) else: vis_discr = self.discr def vis_proj(f): return f from hedge.visualization import SiloVisualizer vis = SiloVisualizer(vis_discr) fields = self.fields self.observer.set_fields_and_state(fields, self.state) from hedge.tools import make_obj_array from pyrticle.cloud import TimesteppablePicState def visualize(observer): sub_timer = self.vis_timer.start_sub_timer() import os.path visf = vis.make_file( os.path.join(setup.output_path, setup.vis_pattern % step)) self.method.add_to_vis(vis, visf, observer.state, time=t, step=step) vis.add_data( visf, [(name, vis_proj(fld)) for name, fld in setup.hook_vis_quantities(observer)], time=t, step=step) setup.hook_visualize(self, vis, visf, observer) visf.close() sub_timer.stop().submit() from hedge.timestep.multirate_ab import TwoRateAdamsBashforthTimeStepper if not isinstance(self.stepper, TwoRateAdamsBashforthTimeStepper): def rhs(t, fields_and_state): fields, ts_state = fields_and_state state_f = lambda: ts_state.state fields_f = lambda: fields fields_rhs = (self.f_rhs_calculator(t, fields_f, state_f) + self.p2f_rhs_calculator(t, fields_f, state_f)) state_rhs = (self.p_rhs_calculator(t, fields_f, state_f) + self.f2p_rhs_calculator(t, fields_f, state_f)) return make_obj_array([fields_rhs, state_rhs]) step_args = (self.dt, rhs) else: def add_unwrap(rhs): def unwrapping_rhs(t, fields, ts_state): return rhs(t, fields, lambda: ts_state().state) return unwrapping_rhs step_args = (( add_unwrap(self.f_rhs_calculator), add_unwrap(self.p2f_rhs_calculator), add_unwrap(self.f2p_rhs_calculator), add_unwrap(self.p_rhs_calculator), ), ) y = make_obj_array( [fields, TimesteppablePicState(self.method, self.state)]) del self.state try: from hedge.timestep import times_and_steps step_it = times_and_steps(max_steps=self.nsteps, logmgr=self.logmgr, max_dt_getter=lambda t: self.dt) for step, t, dt in step_it: self.method.upkeep(y[1].state) if step % setup.vis_interval == 0: visualize(self.observer) y = self.stepper(y, t, *step_args) fields, ts_state = y self.observer.set_fields_and_state(fields, ts_state.state) setup.hook_after_step(self, self.observer) finally: vis.close() self.discr.close() self.logmgr.save() setup.hook_when_done(self) def run(self): if self.setup.profile_output_filename is not None: from cProfile import Profile prof = Profile() try: prof.runcall(self.inner_run) finally: from lsprofcalltree import KCacheGrind kg = KCacheGrind(prof) kg.output(open(self.setup.profile_output_filename, "w")) else: self.inner_run()
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()