def initial_val(discr): # the initial solution for the TE_10-like mode def initial_Hz(x, el): from math import cos, sin if el in material_elements["vacuum"]: return h*cos(h*x[0]) else: return -l*sin(h*d)/sin(l*(a-d))*cos(l*(a-x[0])) from hedge.tools import make_obj_array result_zero = discr.volume_zeros(kind="numpy", dtype=numpy.float64) H_z = make_tdep_given(initial_Hz).volume_interpolant(0, discr) return make_obj_array([result_zero, result_zero, H_z])
def main(write_output=True): from math import sqrt, pi, exp from os.path import join from hedge.backends import guess_run_context rcon = guess_run_context() epsilon0 = 8.8541878176e-12 # C**2 / (N m**2) mu0 = 4*pi*1e-7 # N/A**2. epsilon = 1*epsilon0 mu = 1*mu0 output_dir = "maxwell-2d" import os if not os.access(output_dir, os.F_OK): os.makedirs(output_dir) from hedge.mesh.generator import make_disk_mesh mesh = make_disk_mesh(r=0.5, max_area=1e-3) if rcon.is_head_rank: mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() class CurrentSource: shape = (3,) def __call__(self, x, el): return [0,0,exp(-80*la.norm(x))] order = 3 final_time = 1e-8 discr = rcon.make_discretization(mesh_data, order=order, debug=["cuda_no_plan"]) from hedge.visualization import VtkVisualizer if write_output: vis = VtkVisualizer(discr, rcon, join(output_dir, "em-%d" % order)) if rcon.is_head_rank: print "order %d" % order print "#elements=", len(mesh.elements) from hedge.mesh import TAG_ALL, TAG_NONE from hedge.models.em import TMMaxwellOperator from hedge.data import make_tdep_given, TimeIntervalGivenFunction op = TMMaxwellOperator(epsilon, mu, flux_type=1, current=TimeIntervalGivenFunction( make_tdep_given(CurrentSource()), off_time=final_time/10), absorb_tag=TAG_ALL, pec_tag=TAG_NONE) fields = op.assemble_eh(discr=discr) from hedge.timestep import LSRK4TimeStepper stepper = LSRK4TimeStepper() from time import time last_tstep = time() t = 0 # diagnostics setup --------------------------------------------------- from pytools.log import LogManager, add_general_quantities, \ add_simulation_quantities, add_run_info if write_output: log_file_name = join(output_dir, "maxwell-%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) 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) logmgr.add_watches(["step.max", "t_sim.max", ("W_field", "W_el+W_mag"), "t_step.max"]) # timestep loop ------------------------------------------------------- rhs = op.bind(discr) try: from hedge.timestep import times_and_steps step_it = times_and_steps( final_time=final_time, logmgr=logmgr, max_dt_getter=lambda t: op.estimate_timestep(discr, stepper=stepper, t=t, fields=fields)) for step, t, dt in step_it: if step % 10 == 0 and write_output: e, h = op.split_eh(fields) visf = vis.make_file(join(output_dir, "em-%d-%04d" % (order, step))) vis.add_data(visf, [ ("e", discr.convert_volume(e, "numpy")), ("h", discr.convert_volume(h, "numpy")), ], time=t, step=step ) visf.close() fields = stepper(fields, t, dt, rhs) assert discr.norm(fields) < 0.03 finally: if write_output: vis.close() logmgr.close() discr.close()
def main(write_output=True): from math import sqrt, pi, exp from os.path import join from hedge.backends import guess_run_context rcon = guess_run_context() epsilon0 = 8.8541878176e-12 # C**2 / (N m**2) mu0 = 4 * pi * 1e-7 # N/A**2. epsilon = 1 * epsilon0 mu = 1 * mu0 output_dir = "maxwell-2d" import os if not os.access(output_dir, os.F_OK): os.makedirs(output_dir) from hedge.mesh.generator import make_disk_mesh mesh = make_disk_mesh(r=0.5, max_area=1e-3) if rcon.is_head_rank: mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() class CurrentSource: shape = (3, ) def __call__(self, x, el): return [0, 0, exp(-80 * la.norm(x))] order = 3 final_time = 1e-8 discr = rcon.make_discretization(mesh_data, order=order, debug=["cuda_no_plan"]) from hedge.visualization import VtkVisualizer if write_output: vis = VtkVisualizer(discr, rcon, join(output_dir, "em-%d" % order)) if rcon.is_head_rank: print "order %d" % order print "#elements=", len(mesh.elements) from hedge.mesh import TAG_ALL, TAG_NONE from hedge.models.em import TMMaxwellOperator from hedge.data import make_tdep_given, TimeIntervalGivenFunction op = TMMaxwellOperator(epsilon, mu, flux_type=1, current=TimeIntervalGivenFunction( make_tdep_given(CurrentSource()), off_time=final_time / 10), absorb_tag=TAG_ALL, pec_tag=TAG_NONE) fields = op.assemble_eh(discr=discr) from hedge.timestep import LSRK4TimeStepper stepper = LSRK4TimeStepper() from time import time last_tstep = time() t = 0 # diagnostics setup --------------------------------------------------- from pytools.log import LogManager, add_general_quantities, \ add_simulation_quantities, add_run_info if write_output: log_file_name = join(output_dir, "maxwell-%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) 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) logmgr.add_watches( ["step.max", "t_sim.max", ("W_field", "W_el+W_mag"), "t_step.max"]) # timestep loop ------------------------------------------------------- rhs = op.bind(discr) try: from hedge.timestep import times_and_steps step_it = times_and_steps( final_time=final_time, logmgr=logmgr, max_dt_getter=lambda t: op.estimate_timestep( discr, stepper=stepper, t=t, fields=fields)) for step, t, dt in step_it: if step % 10 == 0 and write_output: e, h = op.split_eh(fields) visf = vis.make_file( join(output_dir, "em-%d-%04d" % (order, step))) vis.add_data(visf, [ ("e", discr.convert_volume(e, "numpy")), ("h", discr.convert_volume(h, "numpy")), ], time=t, step=step) visf.close() fields = stepper(fields, t, dt, rhs) assert discr.norm(fields) < 0.03 finally: if write_output: vis.close() logmgr.close() discr.close()
def main(write_output=True, dir_tag=TAG_NONE, neu_tag=TAG_NONE, rad_tag=TAG_ALL, flux_type_arg="upwind", dtype=numpy.float64, debug=[]): from pytools.stopwatch import Job from math import sin, cos, pi, exp, sqrt from hedge.backends import guess_run_context rcon = guess_run_context() dim = 3 if dim == 1: if rcon.is_head_rank: from hedge.mesh.generator import make_uniform_1d_mesh mesh = make_uniform_1d_mesh(-10, 10, 500) elif dim == 2: from hedge.mesh.generator import make_rect_mesh if rcon.is_head_rank: mesh = make_rect_mesh(a=(-0.5,-0.5),b=(0.5,0.5),max_area=0.008) elif dim == 3: if rcon.is_head_rank: from hedge.mesh.generator import make_ball_mesh mesh = make_ball_mesh(max_volume=0.0005) else: raise RuntimeError, "bad number of dimensions" if rcon.is_head_rank: print "%d elements" % len(mesh.elements) mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() from hedge.timestep.runge_kutta import LSRK4TimeStepper stepper = LSRK4TimeStepper(dtype=dtype) def source_u(x, el): return exp(-numpy.dot(x, x)*128) from hedge.models.wave import StrongWaveOperator from hedge.mesh import TAG_ALL, TAG_NONE from hedge.data import \ make_tdep_given, \ TimeHarmonicGivenFunction, \ TimeIntervalGivenFunction op = StrongWaveOperator(-1, dim, source_f=TimeIntervalGivenFunction( TimeHarmonicGivenFunction( make_tdep_given(source_u), omega=10), 0, 1), dirichlet_tag=dir_tag, neumann_tag=neu_tag, radiation_tag=rad_tag, flux_type=flux_type_arg ) discr = rcon.make_discretization(mesh_data, order=4, debug=debug, default_scalar_type=dtype, tune_for=op.op_template()) from hedge.visualization import VtkVisualizer if write_output: vis = VtkVisualizer(discr, rcon, "fld") from hedge.tools import join_fields fields = join_fields(discr.volume_zeros(dtype=dtype), [discr.volume_zeros(dtype=dtype) for i in range(discr.dimensions)]) # diagnostics setup ------------------------------------------------------- from pytools.log import LogManager, \ add_general_quantities, \ add_simulation_quantities, \ add_run_info if write_output: log_file_name = "wave.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 pytools.log import IntervalTimer vis_timer = IntervalTimer("t_vis", "Time spent visualizing") logmgr.add_quantity(vis_timer) stepper.add_instrumentation(logmgr) from hedge.log import Integral, LpNorm u_getter = lambda: fields[0] logmgr.add_quantity(LpNorm(u_getter, discr, 1, name="l1_u")) logmgr.add_quantity(LpNorm(u_getter, discr, name="l2_u")) logmgr.add_watches(["step.max", "t_sim.max", "l2_u", "t_step.max"]) # timestep loop ----------------------------------------------------------- rhs = op.bind(discr) try: from hedge.timestep import times_and_steps step_it = times_and_steps( final_time=4, 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 step % 10 == 0 and write_output: visf = vis.make_file("fld-%04d" % step) vis.add_data(visf, [ ("u", discr.convert_volume(fields[0], kind="numpy")), ("v", discr.convert_volume(fields[1:], kind="numpy")), ], time=t, step=step) visf.close() fields = stepper(fields, t, dt, rhs) assert discr.norm(fields) < 1 assert fields[0].dtype == dtype finally: if write_output: vis.close() logmgr.close() discr.close()
def main(write_output=True, allow_features=None, flux_type_arg=1, bdry_flux_type_arg=None, extra_discr_args={}): from math import sqrt, pi from hedge.models.em import TEMaxwellOperator 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. c = 1/sqrt(mu0*epsilon0) materials = {"vacuum" : (epsilon0, mu0), "dielectric" : (2*epsilon0, mu0)} output_dir = "2d_cavity" import os if not os.access(output_dir, os.F_OK): os.makedirs(output_dir) # should no tag raise an error or default to free space? def eps_val(x, el): for key in materials.keys(): if el in material_elements[key]: return materials[key][0] raise ValueError, "Element does not belong to any material" def mu_val(x, el): for key in materials.keys(): if el in material_elements[key]: return materials[key][1] raise ValueError, "Element does not belong to any material" # geometry of cavity d = 100e-3 a = 150e-3 # analytical frequency and transverse wavenumbers of resonance f0 = 9.0335649907522321e8 h = 2*pi*f0/c l = -h*sqrt(2) # substitute the following and change materials for a homogeneous cavity #h = pi/a #l =-h def initial_val(discr): # the initial solution for the TE_10-like mode def initial_Hz(x, el): from math import cos, sin if el in material_elements["vacuum"]: return h*cos(h*x[0]) else: return -l*sin(h*d)/sin(l*(a-d))*cos(l*(a-x[0])) from hedge.tools import make_obj_array result_zero = discr.volume_zeros(kind="numpy", dtype=numpy.float64) H_z = make_tdep_given(initial_Hz).volume_interpolant(0, discr) return make_obj_array([result_zero, result_zero, H_z]) if rcon.is_head_rank: from hedge.mesh.reader.gmsh import generate_gmsh mesh = generate_gmsh(CAVITY_GEOMETRY, 2, force_dimension=2) mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() # Work out which elements belong to each material material_elements = {} for key in materials.keys(): material_elements[key] = set(mesh_data.tag_to_elements[key]) order = 3 #extra_discr_args.setdefault("debug", []).append("cuda_no_plan") #extra_discr_args.setdefault("debug", []).append("dump_optemplate_stages") from hedge.data import make_tdep_given from hedge.mesh import TAG_ALL op = TEMaxwellOperator(epsilon=make_tdep_given(eps_val), mu=make_tdep_given(mu_val), \ flux_type=flux_type_arg, \ bdry_flux_type=bdry_flux_type_arg, dimensions=2, pec_tag=TAG_ALL) # op = TEMaxwellOperator(epsilon=epsilon0, mu=mu0, # flux_type=flux_type_arg, \ # bdry_flux_type=bdry_flux_type_arg, dimensions=2, pec_tag=TAG_ALL) discr = rcon.make_discretization(mesh_data, order=order, tune_for=op.op_template(), **extra_discr_args) # create the initial solution fields = initial_val(discr) from hedge.visualization import VtkVisualizer if write_output: from os.path import join vis = VtkVisualizer(discr, rcon, join(output_dir, "cav-%d" % order)) # monitor the solution at a point to find the resonant frequency try: point_getter = discr.get_point_evaluator(numpy.array([75e-3, 25e-3, 0])) #[0.25, 0.25, 0.25])) except RuntimeError: point_getter = None if rcon.is_head_rank: print "---------------------------------------------" print "order %d" % order print "---------------------------------------------" print "#elements=", len(mesh.elements) from hedge.timestep.runge_kutta import LSRK4TimeStepper stepper = LSRK4TimeStepper(dtype=discr.default_scalar_type, rcon=rcon) #from hedge.timestep.dumka3 import Dumka3TimeStepper #stepper = Dumka3TimeStepper(3, dtype=discr.default_scalar_type, rcon=rcon) # diagnostics setup --------------------------------------------------- from pytools.log import LogManager, add_general_quantities, \ add_simulation_quantities, add_run_info if write_output: from os.path import join log_file_name = join(output_dir, "cavity-%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) 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) logmgr.add_watches( ["step.max", "t_sim.max", #("W_field", "W_el+W_mag"), "t_step.max"] ) # timestep loop ------------------------------------------------------- rhs = op.bind(discr) final_time = 10e-9 if point_getter is not None: from os.path import join pointfile = open(join(output_dir, "point.txt"), "wt") done_dt = False try: from hedge.timestep import times_and_steps from os.path import join step_it = times_and_steps( final_time=final_time, 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 step % 10 == 0 and write_output: sub_timer = vis_timer.start_sub_timer() e, h = op.split_eh(fields) visf = vis.make_file(join(output_dir, "cav-%d-%04d") % (order, step)) vis.add_data(visf, [ ("e", discr.convert_volume(e, kind="numpy")), ("h", discr.convert_volume(h, kind="numpy")),], time=t, step=step ) visf.close() sub_timer.stop().submit() fields = stepper(fields, t, dt, rhs) if point_getter is not None: val = point_getter(fields) #print val if not done_dt: pointfile.write("#%g\n" % dt) done_dt = True pointfile.write("%g\n" %val[0]) finally: if write_output: vis.close() logmgr.close() discr.close() if point_getter is not None: pointfile.close()
def main(write_output=True): from math import sin, exp, sqrt from hedge.mesh.generator import make_rect_mesh mesh = make_rect_mesh(a=(-0.5,-0.5),b=(0.5,0.5),max_area=0.008) from hedge.backends.jit import Discretization discr = Discretization(mesh, order=4) from hedge.visualization import VtkVisualizer vis = VtkVisualizer(discr, None, "fld") def source_u(x, el): x = x - numpy.array([0.1,0.22]) return exp(-numpy.dot(x, x)*128) from hedge.data import \ make_tdep_given, \ TimeHarmonicGivenFunction, \ TimeIntervalGivenFunction from hedge.models.wave import StrongWaveOperator from hedge.mesh import TAG_ALL, TAG_NONE op = StrongWaveOperator(-1, discr.dimensions, source_f=TimeIntervalGivenFunction( TimeHarmonicGivenFunction( make_tdep_given(source_u), omega=10), 0, 1), dirichlet_tag=TAG_NONE, neumann_tag=TAG_NONE, radiation_tag=TAG_ALL, flux_type="upwind") from hedge.tools import join_fields fields = join_fields(discr.volume_zeros(), [discr.volume_zeros() for i in range(discr.dimensions)]) from hedge.timestep import RK4TimeStepper stepper = RK4TimeStepper() dt = op.estimate_timestep(discr, stepper=stepper, fields=fields) nsteps = int(1/dt) print "dt=%g nsteps=%d" % (dt, nsteps) rhs = op.bind(discr) for step in range(nsteps): t = step*dt if step % 50 == 0 and write_output: print step, t, discr.norm(fields[0]) visf = vis.make_file("fld-%04d" % step) vis.add_data(visf, [ ("u", fields[0]), ("v", fields[1:]), ], time=t, step=step) visf.close() fields = stepper(fields, t, dt, rhs) vis.close()
def main(write_output=True, flux_type_arg="upwind", dtype=numpy.float64, debug=[]): from pytools.stopwatch import Job from math import sin, cos, pi, exp, sqrt from hedge.backends import guess_run_context rcon = guess_run_context() if rcon.is_head_rank: from hedge.mesh.reader.gmsh import generate_gmsh mesh = generate_gmsh(GEOMETRY, 2, allow_internal_boundaries=True) print "%d elements" % len(mesh.elements) mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() discr = rcon.make_discretization(mesh_data, order=4, debug=debug, default_scalar_type=dtype) from hedge.timestep import RK4TimeStepper stepper = RK4TimeStepper(dtype=dtype) from hedge.visualization import VtkVisualizer if write_output: vis = VtkVisualizer(discr, rcon, "fld") def source_u(x, el): return exp(-numpy.dot(x, x)*128) from hedge.models.wave import StrongWaveOperator from hedge.mesh import TAG_ALL, TAG_NONE from hedge.data import \ make_tdep_given, \ TimeHarmonicGivenFunction, \ TimeIntervalGivenFunction op = StrongWaveOperator(-1, discr.dimensions, source_f=TimeIntervalGivenFunction( TimeHarmonicGivenFunction( make_tdep_given(source_u), omega=10), 0, 1), dirichlet_tag="boundary", neumann_tag=TAG_NONE, radiation_tag=TAG_NONE, flux_type=flux_type_arg ) from hedge.tools import join_fields fields = join_fields(discr.volume_zeros(dtype=dtype), [discr.volume_zeros(dtype=dtype) for i in range(discr.dimensions)]) # diagnostics setup ------------------------------------------------------- from pytools.log import LogManager, \ add_general_quantities, \ add_simulation_quantities, \ add_run_info if write_output: log_file_name = "wiggly.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) logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"]) # timestep loop ----------------------------------------------------------- rhs = op.bind(discr) try: from hedge.timestep import times_and_steps step_it = times_and_steps( final_time=4, 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 step % 10 == 0 and write_output: visf = vis.make_file("fld-%04d" % step) vis.add_data(visf, [ ("u", fields[0]), ("v", fields[1:]), ], time=t, step=step) visf.close() fields = stepper(fields, t, dt, rhs) assert discr.norm(fields) < 1 assert fields[0].dtype == dtype finally: if write_output: vis.close() logmgr.close() discr.close()
def main(write_output=True, \ dir_tag=TAG_NONE, \ neu_tag=TAG_NONE,\ rad_tag=TAG_ALL, flux_type_arg="upwind"): from math import sin, cos, pi, exp, sqrt from hedge.backends import guess_run_context rcon = guess_run_context() dim = 2 if dim == 1: if rcon.is_head_rank: from hedge.mesh.generator import make_uniform_1d_mesh mesh = make_uniform_1d_mesh(-10, 10, 500) elif dim == 2: from hedge.mesh.generator import make_rect_mesh if rcon.is_head_rank: mesh = make_rect_mesh(a=(-1,-1),b=(1,1),max_area=0.003) elif dim == 3: if rcon.is_head_rank: from hedge.mesh.generator import make_ball_mesh mesh = make_ball_mesh(max_volume=0.0005) else: raise RuntimeError, "bad number of dimensions" if rcon.is_head_rank: print "%d elements" % len(mesh.elements) mesh_data = rcon.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() discr = rcon.make_discretization(mesh_data, order=4) from hedge.timestep import RK4TimeStepper stepper = RK4TimeStepper() from hedge.visualization import VtkVisualizer if write_output: vis = VtkVisualizer(discr, rcon, "fld") def source_u(x, el): x = x - numpy.array([0.7, 0.4]) return exp(-numpy.dot(x, x)*256) def c_speed(x, el): if la.norm(x) < 0.4: return 1 else: return 0.5 from hedge.models.wave import VariableVelocityStrongWaveOperator from hedge.data import \ TimeIntervalGivenFunction, \ make_tdep_given from hedge.mesh import TAG_ALL, TAG_NONE op = VariableVelocityStrongWaveOperator( make_tdep_given(c_speed), discr.dimensions, source=TimeIntervalGivenFunction( make_tdep_given(source_u), 0, 0.1), dirichlet_tag=dir_tag, neumann_tag=neu_tag, radiation_tag=rad_tag, flux_type=flux_type_arg ) from hedge.tools import join_fields fields = join_fields(discr.volume_zeros(), [discr.volume_zeros() for i in range(discr.dimensions)]) # diagnostics setup ------------------------------------------------------- from pytools.log import LogManager, \ add_general_quantities, \ add_simulation_quantities, \ add_run_info if write_output: log_file_name = "wave.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 pytools.log import IntervalTimer vis_timer = IntervalTimer("t_vis", "Time spent visualizing") logmgr.add_quantity(vis_timer) stepper.add_instrumentation(logmgr) from hedge.log import Integral, LpNorm u_getter = lambda: fields[0] logmgr.add_quantity(LpNorm(u_getter, discr, 1, name="l1_u")) logmgr.add_quantity(LpNorm(u_getter, discr, name="l2_u")) logmgr.add_watches(["step.max", "t_sim.max", "l2_u", "t_step.max"]) # timestep loop ----------------------------------------------------------- rhs = op.bind(discr) try: dt = op.estimate_timestep(discr, stepper=stepper, fields=fields) if flux_type_arg == "central": dt *= 0.25 from hedge.timestep import times_and_steps step_it = times_and_steps(final_time=3, logmgr=logmgr, max_dt_getter=lambda t: dt) for step, t, dt in step_it: if step % 10 == 0 and write_output: visf = vis.make_file("fld-%04d" % step) vis.add_data(visf, [ ("u", fields[0]), ("v", fields[1:]), ("c", op.c.volume_interpolant(0, discr)), ], time=t, step=step) visf.close() fields = stepper(fields, t, dt, rhs) assert discr.norm(fields) < 1 finally: if write_output: vis.close() logmgr.close() discr.close()
def main(write_output=['vtu', 'receivers'], allow_features='', dim=2, order=4, stfree_tag=TAG_NONE, fix_tag=TAG_ALL, op_tag=TAG_NONE, flux_type="lf", max_steps=None, output_dir='output', pml=None, sources=None, source_param={}, final_time=12, quiet_output=True, nonlinearity_type=None, mesh_file='', periodicity=None, material_files=None, vtu_every=20): """ Parameters: @param write_output: output data, among 'vtu', 'receivers' and 'txt' @param allow_features: 'mpi' or 'cuda' @param dim: 1, 2 or 3 @param order: the order of the method @param stfree_tag: which elements to mark as stress-free boundaries @param fix_tag: which elements to mark as fixed boundaries @param op_tag: which elements to mark as open boundaries @param flux_type: 'lf' (Lax-Freidrich flux) or 'central' @param max_steps: None (no limit) or maximum number of steps to compute @param output_dir: directory where to write the output @param pml: None or NPML widths in this order: [x_l, y_l, z_l, x_r, y_r, z_r] @param sources: an array containing the coordinates of the source or None @param source_param: a dict containing the parameters for the source functions @param final_time: number of seconds of simulations to compute @param quiet_output: if True, only the main thread will print information @param nonlinearity_type: None (linear) or 'classical' (non-linear) @param mesh_file: the file to use as a mesh, or '' in 1D @param periodicity: the names of the boundaries to stick together, or None @param material_files: array, the material files (.dat) to use @param vtu_every: n, to write a vtu file every n steps """ rcon = guess_run_context(allow_features) rcon_init = guess_run_context(allow_features) debug = ['dump_optemplate_stages'] dtype = numpy.float64 if 'cuda' in allow_features: dtype = numpy.float32 debug.append('cuda_no_plan') if rcon.is_head_rank and output_dir and not access(output_dir, F_OK): makedirs(output_dir) if quiet_output: print_output = rcon.is_head_rank else: print_output = True if print_output: print "Using features:", ', '.join(allow_features).upper() nbranks = len(rcon.ranks) print "Using", nbranks, "rank" + ('s' if nbranks > 1 else '') print "Using", dim, "dimension" + ('s' if dim > 1 else '') print "Rank", rcon.rank, "will print its output." else: print "Rank", rcon.rank, "will be silent." class Receiver(): pass assert dim in [1, 2, 3], 'Bad number of dimensions' # Define mesh --- mesh = None if mesh_file != '': mesh = read_gmsh(mesh_file, force_dimension=dim, periodicity=periodicity, allow_internal_boundaries=False, tag_mapper=lambda tag: tag) elif dim == 1: from hedge.mesh.generator import make_uniform_1d_mesh mesh = make_uniform_1d_mesh(-10, 10, 500) else: raise Exception('Error: No mesh file specified!') if rcon.is_head_rank: print "Using %d elements and order %d" % (len(mesh.elements), order) mesh_data = rcon.distribute_mesh(mesh) mesh_init = rcon_init.distribute_mesh(mesh) else: mesh_data = rcon.receive_mesh() mesh_init = rcon_init.receive_mesh() if mesh_file: from libraries.gmsh_reader import GmshReader gmsh = GmshReader(mesh_file, dim, print_output) # End of mesh definition --- # Define sources --- source = None if sources is not None: #FIXME: "Multiple source points are currently unsupported" source = sources if print_output: print "Using specified source", source else: if print_output: print "No source specified", if mesh_file: if print_output: print "trying to find one in", mesh_file sources = gmsh.pointSources if sources != []: source = sources[0] if print_output: print "Using source", source, "from", mesh_file else: if print_output: print "Error: no source!" else: if print_output: print "and no mesh file!" raise Exception('Error: Could not find any source!') def source_v_x(pos, el): pos = pos - source #return exp(-numpy.dot(pos, pos) / source_param['sigma'] ** 2) return exp(- pos[0]**2 / source_param['sigma'] ** 2) def source_v_y(pos, el): pos = pos - source return 0 def source_v_z(pos, el): pos = pos - source return 0 source_type = None if source_param['type'] == 'Sinus': from libraries.functions import SinusGivenFunction source_type = 'SinusGivenFunction' elif source_param['type'] == 'SineBurst': from libraries.functions import SineBurstGivenFunction source_type = 'SineBurstGivenFunction' elif source_param['type'] == 'Modulated_sinus': from libraries.functions import ModulatedSinusGivenFunction source_type = 'ModulatedSinusGivenFunction' elif source_param['type'] == 'Ricker': from libraries.functions import TimeRickerWaveletGivenFunction source_type = 'TimeRickerWaveletGivenFunction' assert source_type is not None, "Failed to define source function!" source_function = locals()[source_type] print "Using source type:", source_type from hedge.data import make_tdep_given, TimeIntervalGivenFunction def source_i(source_v_i): return TimeIntervalGivenFunction( source_function(make_tdep_given(source_v_i), source_param['fc'], source_param['td']), source_param['begin'], source_param['end']) sources = {'source_x': source_i(source_v_x), 'source_y': source_i(source_v_y), 'source_z': source_i(source_v_z)} # End of sources definition --- # Define materials and link them with elements --- materials = [] constants = ['Density', 'LinearElasticConstants'] if nonlinearity_type == 'cubic': constants.append('ElasticConstant_lambda') constants.append('ElasticConstant_mu') constants.append('QuadraticElasticConstant_f') constants.append('CubicElasticConstant_h') elif nonlinearity_type is not None: constants.append('NonlinearElasticConstants') for material_file in material_files: material = Material(material_file, constants, dtype, print_output) if nonlinearity_type == 'cubic': assert material.lambda_ is not None, "Error: Missing elastic constant lambda in " + file assert material.mu is not None, "Error: Missing elastic constant mu in " + file assert material.f is not None, "Error: Missing quadratic constant f in " + file assert material.h is not None, "Error: Missing cubic constant h in " + file elif nonlinearity_type is not None: # In the nonlinear mode, materials MUST have a nonlinear constants assert material.Cnl is not None, "Error: Missing nonlinear constants in " + file materials.append(material) assert len(materials) > 0, "Error: You must define at least 1 material." # Work out which elements belong to each material material_elements = [] used_materials = [] speeds = [] for num, name in [(0, 'mat1'), (1, 'mat2'), (2, 'mat3')]: if len(materials) > num: if name in mesh_init.tag_to_elements.keys(): elements_list = [el.id for el in mesh_init.tag_to_elements[name]] material_elements.append(elements_list) else: num = 0 speed = (materials[num].C[0, 0] / materials[num].rho) ** 0.5 speeds.append(speed.astype(dtype)) used_materials.append(materials[num]) if print_output: print "Using", materials[num].filename, "as", name speed = max(speeds) if print_output: print "Using max speed:", speed, "m/s" def mat_val(x, el): # Will be used in Evaluate(mat, val) for i in range(len(material_elements)): if el.id in material_elements[i]: return i return 0 # End of materials definition --- # Define the elastodynamics operator and the discretization --- kwargs = { 'dimensions': dim, 'speed': speed, 'material': make_tdep_given(mat_val), 'sources': sources, 'boundaryconditions_tag': \ {'stressfree': stfree_tag, 'fixed': fix_tag, 'open': op_tag}, 'materials': used_materials, 'flux_type': flux_type } operator = None if nonlinearity_type == 'cubic': kwargs['nonlinearity_type'] = nonlinearity_type if pml: from elastodynamic import CubicNPMLElastoDynamicsOperator operator = 'CubicNPMLElastoDynamicsOperator' else: raise NotImplementedError elif nonlinearity_type is not None: kwargs['nonlinearity_type'] = nonlinearity_type if pml: from elastodynamic import QuadraticNPMLElastoDynamicsOperator operator = 'QuadraticNPMLElastoDynamicsOperator' else: from elastodynamic import QuadraticElastoDynamicsOperator operator = 'QuadraticElastoDynamicsOperator' else: if pml: from elastodynamic import NPMLElastoDynamicsOperator operator = "NPMLElastoDynamicsOperator" else: from elastodynamic import ElastoDynamicsOperator operator = "ElastoDynamicsOperator" assert operator is not None, "Failed to define operator!" op = locals()[operator](**kwargs) if print_output: print "Using", operator discr = rcon.make_discretization(mesh_data, order=order, debug=debug, tune_for=op.op_template()) # End of elastodynamics operator and discretization definition --- # Define receivers --- receivers = [] point_receivers = [] if write_output and print_output: print "Using output dir:", output_dir if "receivers" in write_output: i = 0 if mesh_file: receivers = gmsh.pointReceivers if receivers != []: for receiver in receivers: try: point_receiver = Receiver() point_receiver.evaluator = discr.get_point_evaluator(numpy.array(receiver)) point_receiver.done_dt = False point_receiver.id = i point_receiver.coordinates = receiver point_receiver.filename = "receiver_%s.txt" % repr(point_receiver.coordinates) except: if not quiet_output: print "Receiver ignored (point not found):", receiver else: point_receivers.append(point_receiver) i += 1 print "Using", point_receiver.filename, "for receiver", receiver # End of receivers definition --- # Define visualization --- def write_datafile(filename, variables): if rcon is not None and len(rcon.ranks) > 1: filename += "-%04d" % rcon.rank visfile = open(filename + ".txt", "wt") visfile.write("x\ty\t") for name, field in variables: if name == "m": visfile.write("m\t") else: i = 0 for subvect in field: i += 1 assert len(subvect) == len(discr.nodes), "Wrong length!" visfile.write(name + "_" + format(i) + "\t") visfile.write("\n") for i in range(len(discr.nodes)): for coord in discr.nodes[i]: visfile.write(format(coord) + "\t") for name, field in variables: if name == "m": visfile.write(format(field[i]) + "\t") else: for subvect in field: visfile.write(format(subvect[i]) + "\t") visfile.write("\n") visfile.close() if 'vtu' in write_output: from hedge.visualization import VtkVisualizer vis = VtkVisualizer(discr, rcon, 'fld') if output_dir: chdir(output_dir) if 'receivers' in write_output: for point_receiver in point_receivers: point_receiver.pointfile = open(point_receiver.filename, "wt") #sumfile = open("receiver_%s_sum.txt" % rcon.rank, "wt") # End of visualization definition --- # Bind the operator to the discretization --- if pml: coefficients = op.coefficients_from_width(discr, mesh, widths=pml, material=materials[0], alpha_magnitude=2 * pi * source_param['fc'] / 10) rhs = op.bind(discr, coefficients) else: rhs = op.bind(discr) # End of operator binding --- # Define the timestep loop --- t = 0.0 max_txt = '' try: len_fields = op.len_q if pml: len_fields += op.len_f2 fields = make_obj_array([discr.volume_zeros(dtype=dtype) for _ in range(len_fields)]) vector_primitive_factory = None if 'cuda' in allow_features else discr.get_vector_primitive_factory() from hedge.timestep import times_and_steps, LSRK4TimeStepper stepper = LSRK4TimeStepper(vector_primitive_factory=vector_primitive_factory, dtype=dtype) max_dt_getter = lambda t: op.estimate_timestep(discr, stepper=stepper, t=t, fields=fields) step_it = times_and_steps(final_time=final_time, logmgr=None, max_dt_getter=max_dt_getter) for step, t, dt in step_it: if max_steps > 0: max_txt = ' on %d' % max_steps if step > max_steps: break if step % vtu_every == 0: variables = [("m", discr.convert_volume(op.m(fields), "numpy")), ("v", discr.convert_volume(op.v(fields), "numpy")), ("F", discr.convert_volume(op.F(fields), "numpy"))] if print_output: print time.strftime('[%H:%M:%S] ', time.localtime()) + \ 'Step: ' + format(step) + max_txt + '; time: ' + format(t) if 'vtu' in write_output: visf = vis.make_file("fld-%04d" % step) vis.add_data(visf, variables, time=t, step=step) visf.close() if 'txt' in write_output: write_datafile("fld-%04d" % step, variables) if 'receivers' in write_output and point_receivers != []: variables = discr.convert_volume(fields, "numpy") #sum_val = numpy.zeros(len(fields)) #sumfile.write("\n%s " % format(t)) for point_receiver in point_receivers: val = point_receiver.evaluator(variables) if not point_receiver.done_dt: point_receiver.pointfile.write("# dt: %g s\n" % dt) point_receiver.pointfile.write("# m: 1 field\n") point_receiver.pointfile.write("# v: %d fields\n" % dim) point_receiver.pointfile.write("# F: %d fields\n" % op.len_f) point_receiver.pointfile.write("# Coordinates: %s\n# t m " % repr(point_receiver.coordinates)) for i in range(dim): point_receiver.pointfile.write('v%s ' % i) for i in range(op.len_f): point_receiver.pointfile.write("F%s " % i) point_receiver.done_dt = True point_receiver.pointfile.write("\n%s " % format(t)) for i in range(1 + dim + op.len_f): #sum_val[i] += val[i] point_receiver.pointfile.write("%s " % format(val[i])) #for i in range(len(val)): #sumfile.write("%s " % format(sum_val[i])) fields = stepper(fields, t, dt, rhs) finally: if 'vtu' in write_output: vis.close() if 'receivers' in write_output: for point_receiver in point_receivers: point_receiver.pointfile.close() #sumfile.close() discr.close() if output_dir: chdir('..')
def source_i(source_v_i): return TimeIntervalGivenFunction( source_function(make_tdep_given(source_v_i), source_param['fc'], source_param['td']), source_param['begin'], source_param['end'])