def collect_timings(outdir, tic):
# list_timings(TimingClear.keep, [TimingType.wall, TimingType.system])
# t = timings(TimingClear.keep, [TimingType.wall, TimingType.user, TimingType.system])
t = timings(TimingClear.keep, [TimingType.wall])
# Use different MPI reductions
t_sum = MPI.sum(MPI.comm_world, t)
# t_min = MPI.min(MPI.comm_world, t)
# t_max = MPI.max(MPI.comm_world, t)
t_avg = MPI.avg(MPI.comm_world, t)
# Print aggregate timings to screen
print('\n' + t_sum.str(True))
# print('\n'+t_min.str(True))
# print('\n'+t_max.str(True))
print('\n' + t_avg.str(True))
# Store to XML file on rank 0
if MPI.rank(MPI.comm_world) == 0:
f = File(MPI.comm_self, os.path.join(outdir, "timings_aggregate.xml"))
f << t_sum
# f << t_min
# f << t_max
f << t_avg
dump_timings_to_xml(os.path.join(outdir, "timings_avg_min_max.xml"),
TimingClear.clear)
elapsed = time.time() - tic
comm = mpi4py.MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
if rank == 0:
with open(os.path.join(outdir, 'timings.pkl'), 'w') as f:
json.dump({'elapsed': elapsed, 'size': size}, f)
pass
def log_timings(simulation, clear=False):
"""
Print the FEniCS + Ocellaris timings to the log
"""
# Total time spent in the simulation
tottime = time.time() - simulation.t_start
# Get timings from FEniCS and sort by total time spent
tclear = dolfin.TimingClear.clear if clear else dolfin.TimingClear.keep
timingtypes = [
dolfin.TimingType.user,
dolfin.TimingType.system,
dolfin.TimingType.wall,
]
table = dolfin.timings(tclear, timingtypes)
table_lines = table.str(True).split('\n')
simulation.log.info('\nFEniCS timings: %s wall pst' %
table_lines[0][18:])
simulation.log.info(table_lines[1] + '-' * 10)
tmp = [(float(line.split()[-5]), line) for line in table_lines[2:]]
tmp.sort(reverse=True)
for wctime, line in tmp:
simulation.log.info('%s %5.1f%%' % (line, wctime / tottime * 100))
print("l2 error " + str(l2_error))
# Store in error error table
num_cells_t = mesh.num_entities_global(2)
num_particles = len(x)
try:
area_error_half = np.float64((area_half - area_0))
except BaseException:
area_error_half = float("NaN")
l2_error_half = float("NaN")
area_error_end = np.float64((area_end - area_0))
with open(output_table, "a") as write_file:
write_file.write(
"%-12.5g %-15d %-20d %-10.2e %-20.3g %-20.2e %-20.3g %-20.3g \n"
% (
float(dt),
int(num_cells_t),
int(num_particles),
float(l2_error_half),
np.float64(area_error_half),
float(l2_error),
np.float64(area_error_end),
np.float(timer.elapsed()[0]),
))
time_table = timings(TimingClear.keep, [TimingType.wall])
with open(outdir + "timings" + str(nx) + ".log", "w") as out:
out.write(time_table.str(True))
def run_and_calculate_error(N, dt, tmax, polydeg_u, polydeg_p, nu, last=False):
"""
Run Ocellaris and return L2 & H1 errors in the last time step
"""
say(N, dt, tmax, polydeg_u, polydeg_p)
# Setup and run simulation
timingtypes = [
dolfin.TimingType.user, dolfin.TimingType.system,
dolfin.TimingType.wall
]
dolfin.timings(dolfin.TimingClear_clear, timingtypes)
sim = Simulation()
sim.input.read_yaml('disc.inp')
mesh_type = sim.input.get_value('mesh/type')
if mesh_type == 'XML':
# Create unstructured mesh with gmsh
cmd1 = [
'gmsh', '-string',
'lc = %f;' % (3.14 / N), '-o',
'disc_%d.msh' % N, '-2', 'disc.geo'
]
cmd2 = ['dolfin-convert', 'disc_%d.msh' % N, 'disc.xml']
with open('/dev/null', 'w') as devnull:
for cmd in (cmd1, cmd2):
say(' '.join(cmd))
subprocess.call(cmd, stdout=devnull, stderr=devnull)
elif mesh_type == 'UnitDisc':
sim.input.set_value('mesh/N', N // 2)
else:
sim.input.set_value('mesh/Nx', N)
sim.input.set_value('mesh/Ny', N)
sim.input.set_value('time/dt', dt)
sim.input.set_value('time/tmax', tmax)
sim.input.set_value('solver/polynomial_degree_velocity', polydeg_u)
sim.input.set_value('solver/polynomial_degree_pressure', polydeg_p)
sim.input.set_value('physical_properties/nu', nu)
sim.input.set_value('output/stdout_enabled', False)
say('Running with %s %s solver ...' %
(sim.input.get_value('solver/type'),
sim.input.get_value('solver/function_space_velocity')))
t1 = time.time()
setup_simulation(sim)
run_simulation(sim)
duration = time.time() - t1
say('DONE')
# Interpolate the analytical solution to the same function space
Vu = sim.data['Vu']
Vp = sim.data['Vp']
Vr = sim.data['Vrho']
polydeg_r = Vr.ufl_element().degree()
vals = dict(t=sim.time,
dt=sim.dt,
Q=sim.input.get_value('user_code/constants/Q'))
rho_e = dolfin.Expression(
sim.input.get_value('initial_conditions/rho_p/cpp_code'),
degree=polydeg_r,
**vals)
u0e = dolfin.Expression(
sim.input.get_value('initial_conditions/up0/cpp_code'),
degree=polydeg_u,
**vals)
u1e = dolfin.Expression(
sim.input.get_value('initial_conditions/up1/cpp_code'),
degree=polydeg_u,
**vals)
pe = dolfin.Expression(
sim.input.get_value('initial_conditions/p/cpp_code'),
degree=polydeg_p,
**vals)
rho_a = dolfin.project(rho_e, Vr)
u0a = dolfin.project(u0e, Vu)
u1a = dolfin.project(u1e, Vu)
pa = dolfin.project(pe, Vp)
mesh = sim.data['mesh']
n = dolfin.FacetNormal(mesh)
# Correct for possible non-zero average p
int_p = dolfin.assemble(sim.data['p'] * dolfin.dx)
int_pa = dolfin.assemble(pa * dolfin.dx)
vol = dolfin.assemble(dolfin.Constant(1.0) * dolfin.dx(domain=mesh))
pa_avg = int_pa / vol
sim.data['p'].vector()[:] += pa_avg
# Calculate L2 errors
err_rho = calc_err(sim.data['rho'], rho_a)
err_u0 = calc_err(sim.data['u0'], u0a)
err_u1 = calc_err(sim.data['u1'], u1a)
err_p = calc_err(sim.data['p'], pa)
# Calculate H1 errors
err_rho_H1 = calc_err(sim.data['rho'], rho_a, 'H1')
err_u0_H1 = calc_err(sim.data['u0'], u0a, 'H1')
err_u1_H1 = calc_err(sim.data['u1'], u1a, 'H1')
err_p_H1 = calc_err(sim.data['p'], pa, 'H1')
reports = sim.reporting.timestep_xy_reports
say('Num time steps:', sim.timestep)
say('Num cells:', mesh.num_cells())
Co_max, Pe_max = numpy.max(reports['Co']), numpy.max(reports['Pe'])
say('Co_max:', Co_max)
say('Pe_max:', Pe_max)
say('rho_min went from %r to %r' %
(reports['min(rho)'][0], reports['min(rho)'][-1]))
say('rho_max went from %r to %r' %
(reports['max(rho)'][0], reports['max(rho)'][-1]))
m0, m1 = reports['mass'][0], reports['mass'][-1]
say('mass error %.3e (%.3e)' % (m1 - m0, (m1 - m0) / m0))
say('vel repr error %.3e' %
dolfin.assemble(dolfin.dot(sim.data['u'], n) * dolfin.ds))
say('p*dx', int_p)
div_u_Vp = abs(
dolfin.project(dolfin.div(sim.data['u']),
Vp).vector().get_local()).max()
say('div(u)|Vp', div_u_Vp)
div_u_Vu = abs(
dolfin.project(dolfin.div(sim.data['u']),
Vu).vector().get_local()).max()
say('div(u)|Vu', div_u_Vu)
Vdg0 = dolfin.FunctionSpace(mesh, "DG", 0)
div_u_DG0 = abs(
dolfin.project(dolfin.div(sim.data['u']),
Vdg0).vector().get_local()).max()
say('div(u)|DG0', div_u_DG0)
Vdg1 = dolfin.FunctionSpace(mesh, "DG", 1)
div_u_DG1 = abs(
dolfin.project(dolfin.div(sim.data['u']),
Vdg1).vector().get_local()).max()
say('div(u)|DG1', div_u_DG1)
isoparam = mesh.ufl_coordinate_element().degree() > 1
allways_plot = True
if (last or allways_plot) and (
not isoparam or sim.input.get_value('mesh/type') == 'UnitDisc'):
# Plot the results
for fa, name in ((u0a, 'u0'), (u1a, 'u1'), (pa, 'p'), (rho_a, 'rho')):
fh = sim.data[name]
if isoparam:
# Bug in matplotlib plotting for isoparametric elements
mesh2 = dolfin.UnitDiscMesh(dolfin.MPI.comm_world, N // 2, 1,
2)
ue = fa.function_space().ufl_element()
V2 = dolfin.FunctionSpace(mesh2, ue.family(), ue.degree())
fa2, fh2 = dolfin.Function(V2), dolfin.Function(V2)
fa2.vector().set_local(fa.vector().get_local())
fh2.vector().set_local(fh.vector().get_local())
fa, fh = fa2, fh2
discr = '' # '%g_%g_' % (N, dt)
plot(fa, name + ' analytical', '%s%s_1analytical' % (discr, name))
plot(fh, name + ' numerical', '%s%s_2numerical' % (discr, name))
plot(fh - fa, name + ' diff', '%s%s_3diff' % (discr, name))
hmin = mesh.hmin()
return err_rho, err_u0, err_u1, err_p, err_rho_H1, err_u0_H1, err_u1_H1, err_p_H1, hmin, dt, Co_max, Pe_max, duration
