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_setup(units, casename, setup, discr, pusher, visualize=False): from hedge.timestep.runge_kutta import LSRK4TimeStepper from hedge.visualization import SiloVisualizer from hedge.models.em import MaxwellOperator vis = SiloVisualizer(discr) from pyrticle.cloud import PicMethod from pyrticle.deposition.shape import ShapeFunctionDepositor method = PicMethod(discr, units, ShapeFunctionDepositor(), pusher(), 3, 3, debug=set(["verbose_vis"])) e, h = setup.fields(discr) b = units.MU0 * h init_positions = setup.positions(0) init_velocities = setup.velocities(0) nparticles = len(init_positions) state = method.make_state() method.add_particles( state, zip( init_positions, init_velocities, nparticles * [setup.charge], nparticles * [units.EL_MASS], ), nparticles) final_time = setup.final_time() nsteps = setup.nsteps() dt = final_time / nsteps # timestepping ------------------------------------------------------------ from hedge.models.em import MaxwellOperator max_op = MaxwellOperator(epsilon=units.EPSILON0, mu=units.MU0, flux_type=1) fields = max_op.assemble_eh(e, h) from pyrticle.cloud import \ FieldToParticleRhsCalculator, \ ParticleRhsCalculator p_rhs_calculator = ParticleRhsCalculator(method, max_op) f2p_rhs_calculator = FieldToParticleRhsCalculator(method, max_op) def rhs(t, ts_state): return (p_rhs_calculator(t, lambda: fields, lambda: ts_state.state) + f2p_rhs_calculator(t, lambda: fields, lambda: ts_state.state)) stepper = LSRK4TimeStepper() t = 0 bbox = discr.mesh.bounding_box() z_period = bbox[1][2] - bbox[0][2] def check_result(): from hedge.tools import cross deriv_dt = 1e-12 dim = discr.dimensions true_x = setup.positions(t) true_v = setup.velocities(t) true_f = [(p2 - p1) / (2 * deriv_dt) for p1, p2 in zip( setup.momenta(t - deriv_dt), setup.momenta(t + deriv_dt))] state = ts_state.state from pyrticle.tools import NumberShiftableVector vis_info = state.vis_listener.particle_vis_map sim_x = state.positions sim_v = method.velocities(state) sim_f = NumberShiftableVector.unwrap(vis_info["mag_force"] + vis_info["el_force"]) sim_el_f = NumberShiftableVector.unwrap(vis_info["el_force"]) sim_mag_f = NumberShiftableVector.unwrap(vis_info["mag_force"]) local_e = setup.e() local_b = units.MU0 * setup.h() x_err = 0 v_err = 0 f_err = 0 for i in range(len(state)): #real_f = numpy.array(cross(sim_v, setup.charge*local_b)) + setup.charge*local_e my_true_x = true_x[i] my_true_x[2] = my_true_x[2] % z_period if False and i == 0: #print "particle %d" % i print "pos:", la.norm(true_x[i] - sim_x[i]) / la.norm( true_x[i]) #print "vel:", la.norm(true_v[i]-sim_v[i])/la.norm(true_v[i]) #print "force:", la.norm(true_f[i]-sim_f[i])/la.norm(true_f[i]) print "pos:", true_x[i], sim_x[i] #print "vel:", true_v[i], sim_v[i] #print "force:", true_f[i], sim_f[i] #print "forces%d:..." % i, sim_el_f[i], sim_mag_f[i] #print "acc%d:" % i, la.norm(a-sim_a) #u = numpy.vstack((v, sim_v, f, sim_f, real_f)) #print "acc%d:\n%s" % (i, u) #raw_input() def rel_err(sim, true): return la.norm(true - sim) / la.norm(true) x_err = max(x_err, rel_err(sim_x[i], my_true_x)) v_err = max(v_err, rel_err(sim_v[i], true_v[i])) f_err = max(f_err, rel_err(sim_f[i], true_f[i])) return x_err, v_err, f_err # make sure verbose-vis fields are filled from pyrticle.cloud import TimesteppablePicState ts_state = TimesteppablePicState(method, state) del state rhs(t, ts_state) errors = (0, 0, 0) for step in xrange(nsteps): if step % int(setup.nsteps() / 300) == 0: errors = tuple( max(old_err, new_err) for old_err, new_err in zip(errors, check_result())) if visualize: visf = vis.make_file("%s-%04d" % (casename, step)) method.add_to_vis(vis, visf, ts_state.state, time=t, step=step) if True: vis.add_data(visf, [ ("e", e), ("h", h), ], time=t, step=step) else: vis.add_data(visf, [], time=t, step=step) visf.close() method.upkeep(ts_state.state) ts_state = stepper(ts_state, t, dt, rhs) t += dt assert errors[0] < 2e-12, casename + "-pos" assert errors[1] < 2e-13, casename + "-vel" assert errors[2] < 2e-4, casename + "-acc" vis.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 optimize_shape_bandwidth(method, state, analytic_rho, exponent): discr = method.discretization rec = method.depositor adv_radius = method.mesh_data.advisable_particle_radius() radii = [adv_radius * 2**i for i in numpy.linspace(-4, 2, 50)] def set_radius(r): method.depositor.set_shape_function( state, method.get_shape_function_class()( r, method.mesh_data.dimensions, exponent, )) tried_radii = [] l1_errors = [] debug = "shape_bw" in method.debug visualize = set(["shape_bw", "vis_files"]) <= method.debug if visualize: from hedge.visualization import SiloVisualizer vis = SiloVisualizer(discr) import sys if debug: sys.stdout.write("optimizing shape bw (%d attempts): " % len(radii)) for step, radius in enumerate(radii): if debug: sys.stdout.write("%d." % step) sys.stdout.flush() try: try: method.set_ignore_core_warnings(True) set_radius(radius) except RuntimeError, re: if "particle mass is zero" in str(re): continue else: raise finally: method.set_ignore_core_warnings(False) state.derived_quantity_cache.clear() try: try: method.set_ignore_core_warnings(True) rec_rho = method.deposit_rho(state) except RuntimeError, re: if "particle mass is zero" in str(re): continue else: raise finally: method.set_ignore_core_warnings(False) tried_radii.append(radius) l1_errors.append(discr.integral(numpy.abs(rec_rho - analytic_rho))) if visualize: visf = vis.make_file("bwopt-%04d" % step) method.add_to_vis(vis, visf, state, time=radius, step=step) vis.add_data( visf, [ ("rho", rec_rho), #("j", method.deposit_j(state)), ("rho_analytic", analytic_rho), ], expressions=[("rho_diff", "rho-rho_analytic")], time=radius, step=step) try: rec.visualize_grid_quantities except AttributeError: pass else: rec.visualize_grid_quantities(visf, [ ("rho_grid", rec.deposit_grid_rho(state)), ("j_grid", rec.deposit_grid_j(state, method.velocities(state))), ("rho_resid", rec.remap_residual(rec.deposit_grid_rho(state))), ]) visf.close() if debug: sys.stdout.write("\n") sys.stdout.flush() if visualize: vis.close() from pytools import argmin min_idx = argmin(l1_errors) min_rad = tried_radii[min_idx] min_l1_error = l1_errors[min_idx] rel_l1_error = abs(min_l1_error / discr.integral(analytic_rho)) if rel_l1_error > 0.1: from warnings import warn warn("Charge density is very poorly resolved (rel L1 error=%g)" % rel_l1_error) def is_local_minimum(list, i): if i == 0: return False elif i == len(list) - 1: return False else: return list[i] < list[i - 1] and list[i] < list[i + 1] local_minima = [ idx for idx in range(len(tried_radii)) if is_local_minimum(l1_errors, idx) ] chosen_idx = max(local_minima) chosen_rad = tried_radii[chosen_idx] if "shape_bw" in method.debug: chosen_l1_error = l1_errors[chosen_idx] print "radius: guessed optimum=%g, found optimum=%g, chosen=%g" % ( adv_radius, min_rad, chosen_rad) print "radius: optimum l1 error=%g, chosen l1 error=%g" % ( min_l1_error, chosen_l1_error) set_radius(chosen_rad) state.derived_quantity_cache.clear() if set(["interactive", "shape_bw"]) < method.debug: from pylab import semilogx, show semilogx(tried_radii, l1_errors) show()
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 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()
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_setup(units, casename, setup, discr, pusher, visualize=False): from hedge.timestep.runge_kutta import LSRK4TimeStepper from hedge.visualization import SiloVisualizer from hedge.models.em import MaxwellOperator vis = SiloVisualizer(discr) from pyrticle.cloud import PicMethod from pyrticle.deposition.shape import ShapeFunctionDepositor method = PicMethod(discr, units, ShapeFunctionDepositor(), pusher(), 3, 3, debug=set(["verbose_vis"])) e, h = setup.fields(discr) b = units.MU0 * h init_positions = setup.positions(0) init_velocities = setup.velocities(0) nparticles = len(init_positions) state = method.make_state() method.add_particles(state, zip(init_positions, init_velocities, nparticles * [setup.charge], nparticles * [units.EL_MASS], ), nparticles) final_time = setup.final_time() nsteps = setup.nsteps() dt = final_time/nsteps # timestepping ------------------------------------------------------------ from hedge.models.em import MaxwellOperator max_op = MaxwellOperator( epsilon=units.EPSILON0, mu=units.MU0, flux_type=1) fields = max_op.assemble_eh(e, h) from pyrticle.cloud import \ FieldToParticleRhsCalculator, \ ParticleRhsCalculator p_rhs_calculator = ParticleRhsCalculator(method, max_op) f2p_rhs_calculator = FieldToParticleRhsCalculator(method, max_op) def rhs(t, ts_state): return (p_rhs_calculator(t, lambda: fields, lambda: ts_state.state) + f2p_rhs_calculator(t, lambda: fields, lambda: ts_state.state)) stepper = LSRK4TimeStepper() t = 0 bbox = discr.mesh.bounding_box() z_period = bbox[1][2] - bbox[0][2] def check_result(): from hedge.tools import cross deriv_dt = 1e-12 dim = discr.dimensions true_x = setup.positions(t) true_v = setup.velocities(t) true_f = [(p2-p1)/(2*deriv_dt) for p1, p2 in zip(setup.momenta(t-deriv_dt), setup.momenta(t+deriv_dt))] state = ts_state.state from pyrticle.tools import NumberShiftableVector vis_info = state.vis_listener.particle_vis_map sim_x = state.positions sim_v = method.velocities(state) sim_f = NumberShiftableVector.unwrap( vis_info["mag_force"] + vis_info["el_force"]) sim_el_f = NumberShiftableVector.unwrap(vis_info["el_force"]) sim_mag_f = NumberShiftableVector.unwrap(vis_info["mag_force"]) local_e = setup.e() local_b = units.MU0 * setup.h() x_err = 0 v_err = 0 f_err = 0 for i in range(len(state)): #real_f = numpy.array(cross(sim_v, setup.charge*local_b)) + setup.charge*local_e my_true_x = true_x[i] my_true_x[2] = my_true_x[2] % z_period if False and i == 0: #print "particle %d" % i print "pos:", la.norm(true_x[i]-sim_x[i])/la.norm(true_x[i]) #print "vel:", la.norm(true_v[i]-sim_v[i])/la.norm(true_v[i]) #print "force:", la.norm(true_f[i]-sim_f[i])/la.norm(true_f[i]) print "pos:", true_x[i], sim_x[i] #print "vel:", true_v[i], sim_v[i] #print "force:", true_f[i], sim_f[i] #print "forces%d:..." % i, sim_el_f[i], sim_mag_f[i] #print "acc%d:" % i, la.norm(a-sim_a) #u = numpy.vstack((v, sim_v, f, sim_f, real_f)) #print "acc%d:\n%s" % (i, u) #raw_input() def rel_err(sim, true): return la.norm(true-sim)/la.norm(true) x_err = max(x_err, rel_err(sim_x[i], my_true_x)) v_err = max(v_err, rel_err(sim_v[i], true_v[i])) f_err = max(f_err, rel_err(sim_f[i], true_f[i])) return x_err, v_err, f_err # make sure verbose-vis fields are filled from pyrticle.cloud import TimesteppablePicState ts_state = TimesteppablePicState(method, state) del state rhs(t, ts_state) errors = (0, 0, 0) for step in xrange(nsteps): if step % int(setup.nsteps()/300) == 0: errors = tuple( max(old_err, new_err) for old_err, new_err in zip(errors, check_result())) if visualize: visf = vis.make_file("%s-%04d" % (casename, step)) method.add_to_vis(vis, visf, ts_state.state, time=t, step=step) if True: vis.add_data(visf, [ ("e", e), ("h", h), ], time=t, step=step) else: vis.add_data(visf, [], time=t, step=step) visf.close() method.upkeep(ts_state.state) ts_state = stepper(ts_state, t, dt, rhs) t += dt assert errors[0] < 2e-12, casename+"-pos" assert errors[1] < 2e-13, casename+"-vel" assert errors[2] < 2e-4, casename+"-acc" vis.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(): 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()
def optimize_shape_bandwidth(method, state, analytic_rho, exponent): discr = method.discretization rec = method.depositor adv_radius = method.mesh_data.advisable_particle_radius() radii = [adv_radius*2**i for i in numpy.linspace(-4, 2, 50)] def set_radius(r): method.depositor.set_shape_function( state, method.get_shape_function_class() (r, method.mesh_data.dimensions, exponent,)) tried_radii = [] l1_errors = [] debug = "shape_bw" in method.debug visualize = set(["shape_bw", "vis_files"]) <= method.debug if visualize: from hedge.visualization import SiloVisualizer vis = SiloVisualizer(discr) import sys if debug: sys.stdout.write("optimizing shape bw (%d attempts): " % len(radii)) for step, radius in enumerate(radii): if debug: sys.stdout.write("%d." % step) sys.stdout.flush() try: try: method.set_ignore_core_warnings(True) set_radius(radius) except RuntimeError, re: if "particle mass is zero" in str(re): continue else: raise finally: method.set_ignore_core_warnings(False) state.derived_quantity_cache.clear() try: try: method.set_ignore_core_warnings(True) rec_rho = method.deposit_rho(state) except RuntimeError, re: if "particle mass is zero" in str(re): continue else: raise finally: method.set_ignore_core_warnings(False) tried_radii.append(radius) l1_errors.append(discr.integral(numpy.abs(rec_rho-analytic_rho))) if visualize: visf = vis.make_file("bwopt-%04d" % step) method.add_to_vis(vis, visf, state, time=radius, step=step) vis.add_data(visf, [ ("rho", rec_rho), #("j", method.deposit_j(state)), ("rho_analytic", analytic_rho), ], expressions=[("rho_diff", "rho-rho_analytic")], time=radius, step=step) try: rec.visualize_grid_quantities except AttributeError: pass else: rec.visualize_grid_quantities(visf, [ ("rho_grid", rec.deposit_grid_rho(state)), ("j_grid", rec.deposit_grid_j(state, method.velocities(state))), ("rho_resid", rec.remap_residual(rec.deposit_grid_rho(state))), ]) visf.close() if debug: sys.stdout.write("\n") sys.stdout.flush() if visualize: vis.close() from pytools import argmin min_idx = argmin(l1_errors) min_rad = tried_radii[min_idx] min_l1_error = l1_errors[min_idx] rel_l1_error = abs(min_l1_error / discr.integral(analytic_rho)) if rel_l1_error > 0.1: from warnings import warn warn("Charge density is very poorly resolved (rel L1 error=%g)" % rel_l1_error) def is_local_minimum(list, i): if i == 0: return False elif i == len(list)-1: return False else: return list[i] < list[i-1] and list[i] < list[i+1] local_minima = [idx for idx in range(len(tried_radii)) if is_local_minimum(l1_errors, idx)] chosen_idx = max(local_minima) chosen_rad = tried_radii[chosen_idx] if "shape_bw" in method.debug: chosen_l1_error = l1_errors[chosen_idx] print "radius: guessed optimum=%g, found optimum=%g, chosen=%g" % ( adv_radius, min_rad, chosen_rad) print "radius: optimum l1 error=%g, chosen l1 error=%g" % ( min_l1_error, chosen_l1_error) set_radius(chosen_rad) state.derived_quantity_cache.clear() if set(["interactive", "shape_bw"]) < method.debug: from pylab import semilogx, show semilogx(tried_radii, l1_errors) show()
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 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()
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()