x0, y0, r = op.source_loc[0]
return conditional(le(abs((x - x0)**2 + (y - y0)**2 - r**2), eps), alpha,
1.0)
mesh_mover = MeshMover(tp.meshes[0], monitor, method='monge_ampere', op=op)
mesh_mover.adapt()
tp.__init__(op, meshes=[Mesh(mesh_mover.x)])
# --- Solve the tracer transport problem
# Note:
# * Pure Lagrangian leads to tangled elements after only a few iterations
# * This motivates applying monitor based methods throughout the simulation
tp.set_initial_condition()
init_vol = assemble(Constant(1.0) * dx(domain=tp.mesh))
init_l1_norm = norm(tp.fwd_solutions_tracer[0], norm_type='L1')
init_l2_norm = norm(tp.fwd_solutions_tracer[0], norm_type='L2')
init_sol = tp.fwd_solutions_tracer[0].copy(deepcopy=True)
tp.solve_forward()
# Compare initial and final tracer concentrations
final_vol = assemble(Constant(1.0) * dx(domain=tp.mesh))
final_l1_norm = norm(tp.fwd_solutions_tracer[0], norm_type='L1')
final_l2_norm = norm(tp.fwd_solutions_tracer[0], norm_type='L2')
final_sol = tp.fwd_solutions_tracer[0].copy(deepcopy=True)
abs_l2_error = errornorm(init_sol, final_sol, norm_type='L2')
print_output("Volume error: {:.2f}%".format(
100 * abs(init_vol - final_vol) / init_vol))
print_output("Conservation error: {:.2f}%".format(
# Discretisation
'tracer_family': args.family or 'dg',
'stabilisation_tracer': args.stabilisation,
'use_limiter_for_tracers': bool(args.limiters or True),
'use_tracer_conservative_form': bool(args.conservative or False),
# Misc
'debug': bool(args.debug or False),
}
# --- Create solver and copy initial solution
ep = AdaptiveProblem(CosinePrescribedVelocityOptions(**kwargs))
ep.set_initial_condition()
init_sol = ep.fwd_solutions_tracer[0].copy(deepcopy=True)
init_norm = norm(init_sol)
# --- Eulerian interpretation
ep.solve_forward()
final_sol_eulerian = ep.fwd_solutions_tracer[-1]
relative_error_eulerian = abs(errornorm(init_sol, final_sol_eulerian)/init_norm)
print_output("Relative error in Eulerian case: {:.2f}%".format(100*relative_error_eulerian))
# --- Lagrangian interpretation
kwargs['approach'] = 'lagrangian'
op.dt = 0.01*0.5**n
op.dt_per_export = 2**n
# Run simulation
tp = AdaptiveProblem(op)
cpu_timestamp = perf_counter()
tp.run()
times = [perf_counter() - cpu_timestamp]
dofs = [Q.dof_count for Q in tp.Q]
num_cells = [mesh.num_cells() for mesh in tp.meshes]
# Assess error
final_sol = tp.fwd_solutions_tracer[-1].copy(deepcopy=True)
final_l1_norm = norm(final_sol, norm_type='L1')
final_l2_norm = norm(final_sol, norm_type='L2')
tp.set_initial_condition(i=-1)
init_sol = tp.fwd_solutions_tracer[-1].copy(deepcopy=True)
init_l1_norm = norm(init_sol, norm_type='L1')
init_l2_norm = norm(init_sol, norm_type='L2')
abs_l2_error = errornorm(init_sol, final_sol, norm_type='L2')
cons_error = [100*abs(init_l1_norm-final_l1_norm)/init_l1_norm]
l2_error = [100*abs_l2_error/init_l2_norm]
# Save to HDF5
with h5py.File(os.path.join(op.di, 'convergence_{:d}.h5'.format(n)), 'w') as outfile:
outfile.create_dataset('iterations', data=[tp.outer_iteration])
outfile.create_dataset('elements', data=num_cells)
outfile.create_dataset('dofs', data=dofs)
outfile.create_dataset('time', data=times)
outfile.create_dataset('l2_error', data=l2_error)
outfile.create_dataset('cons_error', data=cons_error)
elif basis == 'okada':
from adapt_utils.case_studies.tohoku.options.okada_options import TohokuOkadaBasisOptions
constructor = TohokuOkadaBasisOptions
else:
raise ValueError("Basis type '{:s}' not recognised.".format(basis))
fontsize = 22
fontsize_tick = 20
# Load control parameters
fname = os.path.join(data_dir, 'discrete', 'optimisation_progress_{:s}' + '_{:d}.npy'.format(level))
kwargs['control_parameters'] = np.load(fname.format('ctrl', level))[-1]
op = constructor(**kwargs)
# Plot source over whole domain
swp = AdaptiveProblem(op)
swp.set_initial_condition()
fig, axes = plt.subplots(figsize=(8, 7))
cbar = fig.colorbar(
tricontourf(swp.fwd_solutions[0].split()[1], levels=50, cmap='coolwarm', axes=axes),
ax=axes)
cbar.set_label(r'Elevation [$\mathrm m$]', size=fontsize)
axes.axis(False)
cbar.ax.tick_params(labelsize=fontsize_tick)
plt.tight_layout()
savefig('optimised_source_{:d}'.format(level), fpath=plot_dir, extensions=plot.extensions)
# Zoom
lonlat_corners = [(138, 32), (148, 42), (138, 42)]
utm_corners = [lonlat_to_utm(*corner, 54) for corner in lonlat_corners]
xlim = [utm_corners[0][0], utm_corners[1][0]]
ylim = [utm_corners[0][1], utm_corners[2][1]]