def compare_pressure(self):
"""
Compares the pressure field node by node with a reference.
"""
time_step = ioPetIBM.get_time_steps(directory=self.directory)[-1]
grid = ioPetIBM.read_grid(directory=self.directory)
pressure = ioPetIBM.read_pressure(time_step,
grid,
directory=self.directory)
grid = ioPetIBM.read_grid(directory=self.reference)
pressure_reference = ioPetIBM.read_pressure(time_step,
grid,
directory=self.reference)
self.compare_arrays(pressure.x,
pressure_reference.x,
tag='pressure: x-nodes')
self.compare_arrays(pressure.y,
pressure_reference.y,
tag='pressure: y-nodes')
try:
self.compare_arrays(pressure.z,
pressure_reference.z,
tag='pressure: z-nodes')
except:
pass
self.compare_arrays(pressure.values,
pressure_reference.values,
tag='pressure: values')
def main():
"""Interpolates the solution from a grid to another."""
args = read_inputs()
# reference solution
reference = {}
if not args.time_step:
args.time_step = sorted(int(folder)
for folder in os.listdir(args.reference_directory)
if folder[0]=='0')[-1]
reference['input'] = '{}/{:0>7}'.format(args.reference_directory,
args.time_step)
# new simulation
case = {}
case['output'] = '{}/0000000'.format(args.case_directory)
if args.same_grid:
print('Same grid, data are simply copied ...')
if os.path.isdir(case['output']):
shutil.rmtree(case['output'])
shutil.copytree(reference['input'], case['output'])
return
# read reference solution
reference['grid'] = ioPetIBM.read_grid(args.reference_directory)
reference['u'], reference['v'], reference['w'] = ioPetIBM.read_velocity(args.reference_directory,
args.time_step,
reference['grid'],
periodic=args.periodic)
reference['p'] = ioPetIBM.read_pressure(args.reference_directory,
args.time_step,
reference['grid'])
def main():
"""Converts PETSc output to .vtk format."""
# parse command-line
args = read_inputs()
print('[case-directory] {}'.format(args.case_directory))
print('[variables] {}'.format(args.variables))
# list of time-steps to post-process
time_steps = ioPetIBM.get_time_steps(args.case_directory, args.time_steps)
# read mesh grid
grid = ioPetIBM.read_grid(args.case_directory)
for time_step in time_steps:
if 'velocity' in args.variables:
velocity = ioPetIBM.read_velocity(args.case_directory, time_step, grid,
periodic=args.periodic)
# need to get velocity at cell-centers, not staggered arrangement
velocity = interpolate_cell_centers(velocity)
ioPetIBM.write_vtk(velocity, args.case_directory, time_step,
name='velocity',
view=[args.bottom_left, args.top_right],
stride=args.stride)
if 'pressure' in args.variables:
pressure = ioPetIBM.read_pressure(args.case_directory, time_step, grid)
ioPetIBM.write_vtk(pressure, args.case_directory, time_step,
name='pressure',
view=[args.bottom_left, args.top_right],
stride=args.stride)
def main(args):
"""
Generates .vtk files out of the saved PETSc solutions.
Parameters
----------
args: namespace
Databased with arguments parsed from the command-line.
"""
print('[directory] {}'.format(args.directory))
print('[variables] {}'.format(args.variables))
# list of time-steps to post-process
time_steps = ioPetIBM.get_time_steps(args.directory, args.time_steps)
# read mesh grid
grid = ioPetIBM.read_grid(args.directory)
for time_step in time_steps:
if 'velocity' in args.variables:
velocity = ioPetIBM.read_velocity(args.directory, time_step, grid,
periodic=args.periodic)
# need to get velocity at cell-centers, not staggered arrangement
velocity = interpolate_cell_centers(velocity)
ioPetIBM.write_vtk(velocity, args.directory, time_step,
name='velocity',
view=[args.bottom_left, args.top_right],
stride=args.stride)
if 'pressure' in args.variables:
pressure = ioPetIBM.read_pressure(args.directory, time_step, grid)
ioPetIBM.write_vtk(pressure, args.directory, time_step,
name='pressure',
view=[args.bottom_left, args.top_right],
stride=args.stride)
def main():
"""Plots the the velocity, pressure and vorticity fields at saved time-steps
for a two-dimensional simulation.
"""
# parse command-line
args = read_inputs()
print('[case directory] {}'.format(args.case_directory))
time_steps = ioPetIBM.get_time_steps(args.case_directory, args.time_steps)
# create directory where images will be saved
images_directory = '{}/images'.format(args.case_directory)
print('[images directory] {}'.format(images_directory))
if not os.path.isdir(images_directory):
os.makedirs(images_directory)
# read the grid nodes
coords = ioPetIBM.read_grid(args.case_directory)
# load default style of matplotlib figures
pyplot.style.use('{}/scripts/python/style/'
'style_PetIBM.mplstyle'.format(os.environ['PETIBM_DIR']))
for time_step in time_steps:
if args.velocity or args.vorticity:
# get velocity fields
u, v = ioPetIBM.read_velocity(args.case_directory, time_step, coords,
periodic=args.periodic)
if args.velocity:
# plot u-velocity field
u.label = 'u-velocity'
image_path = '{}/uVelocity{:0>7}.png'.format(images_directory, time_step)
plot_contour(u, args.u_range, image_path,
view=args.bottom_left+args.top_right,
size=args.size, dpi=args.dpi)
# plot v-velocity field
v.label = 'v-velocity'
image_path = '{}/vVelocity{:0>7}.png'.format(images_directory, time_step)
plot_contour(v, args.v_range, image_path,
view=args.bottom_left+args.top_right,
size=args.size, dpi=args.dpi)
if args.vorticity:
# compute vorticity field
w = vorticity(u, v)
# plot vorticity field
w.label = 'vorticity'
image_path = '{}/vorticity{:0>7}.png'.format(images_directory, time_step)
plot_contour(w, args.vorticity_range, image_path,
view=args.bottom_left+args.top_right,
size=args.size, dpi=args.dpi)
if args.pressure:
# get pressure field
p = ioPetIBM.read_pressure(args.case_directory, time_step, coords)
# plot pressure field
p.label = 'pressure'
image_path = '{}/pressure{:0>7}.png'.format(images_directory, time_step)
plot_contour(p, args.pressure_range, image_path,
view=args.bottom_left+args.top_right,
size=args.size, dpi=args.dpi)
def compare_pressure(self):
"""Compares the pressure field node by node with a reference."""
time_step = ioPetIBM.get_time_steps(self.directory)[-1]
grid = ioPetIBM.read_grid(self.directory)
pressure = ioPetIBM.read_pressure(self.directory, time_step, grid)
grid = ioPetIBM.read_grid(self.reference)
pressure_reference = ioPetIBM.read_pressure(self.reference, time_step, grid)
self.compare_arrays(pressure.x, pressure_reference.x,
tag='pressure: x-nodes')
self.compare_arrays(pressure.y, pressure_reference.y,
tag='pressure: y-nodes')
try:
self.compare_arrays(pressure.z, pressure_reference.z,
tag='pressure: z-nodes')
except:
pass
self.compare_arrays(pressure.values, pressure_reference.values,
tag='pressure: values')
def main():
"""Converts PETSc output to .vtk format."""
# parse command-line
args = read_inputs()
print('[case-directory] {}'.format(args.case_directory))
print('[variables] {}'.format(args.variables))
# list of time-steps to post-process
time_steps = ioPetIBM.get_time_steps(args.case_directory, args.time_steps)
# read mesh grid
grid = ioPetIBM.read_grid(args.case_directory)
for time_step in time_steps:
if 'velocity' in args.variables:
velocity = ioPetIBM.read_velocity(args.case_directory,
time_step,
grid,
periodic=args.periodic)
# need to get velocity at cell-centers, not staggered arrangement
velocity = interpolate_cell_centers(velocity)
ioPetIBM.write_vtk(velocity,
args.case_directory,
time_step,
name='velocity',
view=[args.bottom_left, args.top_right],
stride=args.stride)
if 'pressure' in args.variables:
pressure = ioPetIBM.read_pressure(args.case_directory, time_step,
grid)
ioPetIBM.write_vtk(pressure,
args.case_directory,
time_step,
name='pressure',
view=[args.bottom_left, args.top_right],
stride=args.stride)
def main():
"""Plots the grid convergence for the Taylor-Green vortex case."""
# parse command-line
args = read_inputs()
# initialization
simulations = sorted(int(directory)
for directory in os.listdir(args.directory)
if os.path.isdir('/'.join([args.directory, directory])))
cases = numpy.empty(len(simulations), dtype=dict)
for i, case in enumerate(cases):
cases[i] = {'directory': '{}/{}'.format(args.directory, simulations[i]),
'grid-size': '{0}x{0}'.format(simulations[i])}
for i, case in enumerate(cases):
print('\n[case] grid-size: {}'.format(case['grid-size']))
# read mesh grid
x, y = ioPetIBM.read_grid(case['directory'])
cases[i]['grid-spacing'] = (x[-1]-x[0])/(x.size-1)
# read velocity and pressure fields
cases[i]['u'], cases[i]['v'] = ioPetIBM.read_velocity(case['directory'],
args.time_step,
[x, y],
periodic=['x', 'y'])
cases[i]['p'] = ioPetIBM.read_pressure(case['directory'], args.time_step, [x, y])
# compute analytical solution
cases[i]['u'].exact, _, _, _ = taylor_green_vortex(case['u'].x,
case['u'].y,
V=args.amplitude,
time=args.time_step*args.dt,
Re=args.Re)
_, cases[i]['v'].exact, _, _ = taylor_green_vortex(case['v'].x,
case['v'].y,
V=args.amplitude,
time=args.time_step*args.dt,
Re=args.Re)
_, _, cases[i]['p'].exact, _ = taylor_green_vortex(case['p'].x,
case['p'].y,
V=args.amplitude,
time=args.time_step*args.dt,
Re=args.Re)
# compute L2-norm error
for field in ['u', 'v', 'p']:
cases[i][field].error = (l2_norm(case[field].values-case[field].exact)
/ l2_norm(case[field].exact))
if args.plot:
print('\nPlot the field difference between numerical and analytical ...')
# create directory where images will be saved
images_directory = '{}/images/differences'.format(case['directory'])
if not os.path.isdir(images_directory):
os.makedirs(images_directory)
# load default style
pyplot.style.use('{}/scripts/python/style/'
'style_PetIBM.mplstyle'.format(os.environ['PETIBM_DIR']))
# set parameters of the plots
cases[i]['u'].label = 'u-velocity'
cases[i]['u'].file_name = 'uVelocity'
cases[i]['v'].label = 'v-velocity'
cases[i]['v'].file_name = 'vVelocity'
cases[i]['p'].label = 'pressure'
cases[i]['p'].file_name = 'pressure'
# plot velocity fields and pressure field
for field in ['u', 'v', 'p']:
image_path = '{}/{}{:0>7}_numerical.png'.format(images_directory,
case[field].file_name,
args.time_step)
plot_field(case[field].x, case[field].y, case[field].values,
case[field].label, image_path)
image_path = '{}/{}{:0>7}_analytical.png'.format(images_directory,
case[field].file_name,
args.time_step)
plot_field(case[field].x, case[field].y, case[field].exact,
case[field].label, image_path)
image_path = '{}/{}{:0>7}_difference.png'.format(images_directory,
case[field].file_name,
args.time_step)
plot_field(case[field].x, case[field].y, case[field].values-case[field].exact,
case[field].label, image_path)
print('\nObserved order of convergence:')
last_three = True
coarse, medium, fine = cases[-3:] if last_three else cases[:3]
ratio = coarse['grid-spacing']/medium['grid-spacing']
alpha = {'u': compute_order(ratio,
coarse['u'].values,
restriction(medium['u'], coarse['u']).values,
restriction(fine['u'], coarse['u']).values),
'v': compute_order(ratio,
coarse['v'].values,
restriction(medium['v'], coarse['v']).values,
restriction(fine['v'], coarse['v']).values),
'p': compute_order(ratio,
coarse['p'].values,
restriction(medium['p'], coarse['p']).values,
restriction(fine['p'], coarse['p']).values)}
print('\tu: {}'.format(alpha['u']))
print('\tv: {}'.format(alpha['v']))
print('\tp: {}'.format(alpha['p']))
# write orders of convergence into file
file_path = '{}/orders_of_convergence.dat'.format(args.directory)
with open(file_path, 'w') as outfile:
outfile.write('u: {}\n'.format(alpha['u']))
outfile.write('v: {}\n'.format(alpha['v']))
outfile.write('p: {}\n'.format(alpha['p']))
if args.save or args.show:
print('\nPlot the grid convergence ...')
pyplot.style.use('{}/scripts/python/style/'
'style_PetIBM.mplstyle'.format(os.environ['PETIBM_DIR']))
pyplot.xlabel('grid-spacing')
pyplot.ylabel('$L_2$-norm error')
# plot errors in u-velocity
pyplot.plot([case['grid-spacing'] for case in cases],
[case['u'].error for case in cases],
label='u-velocity', marker='o')
# plot errors in v-velocity
pyplot.plot([case['grid-spacing'] for case in cases],
[case['v'].error for case in cases],
label='v-velocity', marker='o')
# plot errors in pressure
pyplot.plot([case['grid-spacing'] for case in cases],
[case['p'].error for case in cases],
label='pressure', marker='o')
# plot convergence-gauge for 1st- and 2nd- orders
h = numpy.linspace(cases[0]['grid-spacing'], cases[-1]['grid-spacing'], 101)
pyplot.plot(h, h, label='$1^{st}$-order convergence', color='k')
pyplot.plot(h, h**2, label='$2^{nd}$-order convergence', color='k', linestyle='--')
pyplot.legend()
pyplot.xscale('log')
pyplot.yscale('log')
if args.save:
pyplot.savefig('{}/{}.png'.format(args.directory, args.output))
if args.show:
pyplot.show()
args.time_step = sorted(
int(folder) for folder in os.listdir(args.reference_directory)
if folder[0] == '0')[-1]
reference['input'] = '{}/{:0>7}'.format(args.reference_directory,
args.time_step)
# new simulation
case = {}
case['output'] = '{}/0000000'.format(args.case_directory)
if args.same_grid:
print('Same grid, data are simply copied ...')
if os.path.isdir(case['output']):
shutil.rmtree(case['output'])
shutil.copytree(reference['input'], case['output'])
return
# read reference solution
reference['grid'] = ioPetIBM.read_grid(args.reference_directory)
reference['u'], reference['v'], reference['w'] = ioPetIBM.read_velocity(
args.reference_directory,
args.time_step,
reference['grid'],
periodic=args.periodic)
reference['p'] = ioPetIBM.read_pressure(args.reference_directory,
args.time_step, reference['grid'])
if __name__ == '__main__':
print('\n[{}] START\n'.format(os.path.basename(__file__)))
main()
print('\n[{}] END\n'.format(os.path.basename(__file__)))
def main():
"""Plots the the velocity, pressure and vorticity fields at saved time-steps
for a two-dimensional simulation.
"""
# parse command-line
args = read_inputs()
print('[case directory] {}'.format(args.case_directory))
time_steps = ioPetIBM.get_time_steps(args.case_directory, args.time_steps)
# create directory where images will be saved
images_directory = '{}/images'.format(args.case_directory)
print('[images directory] {}'.format(images_directory))
if not os.path.isdir(images_directory):
os.makedirs(images_directory)
# read the grid nodes
coords = ioPetIBM.read_grid(args.case_directory)
# load default style of matplotlib figures
pyplot.style.use('{}/scripts/python/style/'
'style_PetIBM.mplstyle'.format(os.environ['PETIBM_DIR']))
for time_step in time_steps:
if args.velocity or args.vorticity:
# get velocity fields
u, v = ioPetIBM.read_velocity(args.case_directory,
time_step,
coords,
periodic=args.periodic)
if args.velocity:
# plot u-velocity field
u.label = 'u-velocity'
image_path = '{}/uVelocity{:0>7}.png'.format(
images_directory, time_step)
plot_contour(u,
args.u_range,
image_path,
view=args.bottom_left + args.top_right,
size=args.size,
dpi=args.dpi)
# plot v-velocity field
v.label = 'v-velocity'
image_path = '{}/vVelocity{:0>7}.png'.format(
images_directory, time_step)
plot_contour(v,
args.v_range,
image_path,
view=args.bottom_left + args.top_right,
size=args.size,
dpi=args.dpi)
if args.vorticity:
# compute vorticity field
w = vorticity(u, v)
# plot vorticity field
w.label = 'vorticity'
image_path = '{}/vorticity{:0>7}.png'.format(
images_directory, time_step)
plot_contour(w,
args.vorticity_range,
image_path,
view=args.bottom_left + args.top_right,
size=args.size,
dpi=args.dpi)
if args.pressure:
# get pressure field
p = ioPetIBM.read_pressure(args.case_directory, time_step, coords)
# plot pressure field
p.label = 'pressure'
image_path = '{}/pressure{:0>7}.png'.format(
images_directory, time_step)
plot_contour(p,
args.pressure_range,
image_path,
view=args.bottom_left + args.top_right,
size=args.size,
dpi=args.dpi)
def main(args):
"""
Plots the the velocity, pressure and vorticity fields at saved time-steps
for a two-dimensional simulation.
Parameters
----------
args: namespace
Database with arguments parsed from the command-line.
"""
print('[case directory] {}'.format(args.directory))
time_steps = ioPetIBM.get_time_steps(args.time_steps,
directory=args.directory)
# create directory where images will be saved
images_directory = os.path.join(args.directory, 'images')
print('[images directory] {}'.format(images_directory))
if not os.path.isdir(images_directory):
os.makedirs(images_directory)
# read the grid nodes
coords = ioPetIBM.read_grid(directory=args.directory)
# load default style of matplotlib figures
pyplot.style.use(
os.path.join(os.environ['PETIBM_DIR'], 'scripts', 'python', 'style',
'style_PetIBM.mplstyle'))
for time_step in time_steps:
if args.velocity or args.vorticity:
# get velocity fields
u, v = ioPetIBM.read_velocity(time_step,
coords,
directory=args.directory,
periodic=args.periodic)
if args.velocity:
# plot u-velocity field
u.label = 'u-velocity'
image_path = os.path.join(
images_directory, 'uVelocity{:0>7}.png'.format(time_step))
plot_contour(u,
args.u_range,
image_path,
view=args.bottom_left + args.top_right,
size=args.size,
dpi=args.dpi)
# plot v-velocity field
v.label = 'v-velocity'
image_path = os.path.join(
images_directory, 'vVelocity{:0>7}.png'.format(time_step))
plot_contour(v,
args.v_range,
image_path,
view=args.bottom_left + args.top_right,
size=args.size,
dpi=args.dpi)
if args.vorticity:
# compute vorticity field
w = vorticity(u, v)
# plot vorticity field
w.label = 'vorticity'
image_path = os.path.join(
images_directory, 'vorticity{:0>7}.png'.format(time_step))
plot_contour(w,
args.vorticity_range,
image_path,
view=args.bottom_left + args.top_right,
size=args.size,
dpi=args.dpi)
if args.pressure:
# get pressure field
p = ioPetIBM.read_pressure(time_step,
coords,
directory=args.directory)
# plot pressure field
p.label = 'pressure'
image_path = os.path.join(images_directory,
'pressure{:0>7}.png'.format(time_step))
plot_contour(p,
args.pressure_range,
image_path,
view=args.bottom_left + args.top_right,
size=args.size,
dpi=args.dpi)
def main(args):
"""
Plots the grid convergence for the Taylor-Green vortex case.
Parameters
----------
args: namespace
Database with arguments parsed from the command-line.
"""
# initialization
simulations = sorted(
int(directory) for directory in os.listdir(args.directory)
if os.path.isdir('/'.join([args.directory, directory])))
cases = numpy.empty(len(simulations), dtype=dict)
for i, case in enumerate(cases):
cases[i] = {
'directory': '{}/{}'.format(args.directory, simulations[i]),
'grid-size': '{0}x{0}'.format(simulations[i])
}
for i, case in enumerate(cases):
directory = case['directory']
print('\n[case] grid-size: {}'.format(case['grid-size']))
# read mesh grid
x, y = ioPetIBM.read_grid(directory=directory)
cases[i]['grid-spacing'] = (x[-1] - x[0]) / (x.size - 1)
# read velocity and pressure fields
cases[i]['u'], cases[i]['v'] = ioPetIBM.read_velocity(
args.time_step, [x, y], periodic=['x', 'y'], directory=directory)
cases[i]['p'] = ioPetIBM.read_pressure(args.time_step, [x, y],
directory=directory)
# compute analytical solution
cases[i]['u'].exact, _, _, _ = taylor_green_vortex(
case['u'].x,
case['u'].y,
V=args.amplitude,
time=(args.time_step * args.dt),
Re=args.Re)
_, cases[i]['v'].exact, _, _ = taylor_green_vortex(
case['v'].x,
case['v'].y,
V=args.amplitude,
time=(args.time_step * args.dt),
Re=args.Re)
_, _, cases[i]['p'].exact, _ = taylor_green_vortex(
case['p'].x,
case['p'].y,
V=args.amplitude,
time=(args.time_step * args.dt),
Re=args.Re)
# compute L2-norm error
for field in ['u', 'v', 'p']:
cases[i][field].error = (
l2_norm(case[field].values - case[field].exact) /
l2_norm(case[field].exact))
if args.plot:
print(
'\nPlot the field difference between numerical and analytical ...'
)
# create directory where images will be saved
images_directory = os.path.join(case['directory'], 'images',
'differences')
if not os.path.isdir(images_directory):
os.makedirs(images_directory)
# load default style
pyplot.style.use(
os.path.join(os.environ['PETIBM_DIR'], 'scripts', 'python',
'style', 'style_PetIBM.mplstyle'))
# set parameters of the plots
cases[i]['u'].label = 'u-velocity'
cases[i]['u'].file_name = 'uVelocity'
cases[i]['v'].label = 'v-velocity'
cases[i]['v'].file_name = 'vVelocity'
cases[i]['p'].label = 'pressure'
cases[i]['p'].file_name = 'pressure'
# plot velocity fields and pressure field
for field in ['u', 'v', 'p']:
image_path = os.path.join(
images_directory,
'{}{:0>7}_numerical.png'.format(case[field].file_name,
args.time_step))
plot_field(case[field].x, case[field].y, case[field].values,
case[field].label, image_path)
image_path = os.path.join(
images_directory,
'{}{:0>7}_analytical.png'.format(case[field].file_name,
args.time_step))
plot_field(case[field].x, case[field].y, case[field].exact,
case[field].label, image_path)
image_path = os.path.join(
images_directory,
'{}{:0>7}_difference.png'.format(case[field].file_name,
args.time_step))
plot_field(case[field].x, case[field].y,
case[field].values - case[field].exact,
case[field].label, image_path)
print('\nObserved order of convergence:')
last_three = True
coarse, medium, fine = cases[-3:] if last_three else cases[:3]
ratio = coarse['grid-spacing'] / medium['grid-spacing']
alpha = {
'u':
compute_order(ratio, coarse['u'].values,
restriction(medium['u'], coarse['u']).values,
restriction(fine['u'], coarse['u']).values),
'v':
compute_order(ratio, coarse['v'].values,
restriction(medium['v'], coarse['v']).values,
restriction(fine['v'], coarse['v']).values),
'p':
compute_order(ratio, coarse['p'].values,
restriction(medium['p'], coarse['p']).values,
restriction(fine['p'], coarse['p']).values)
}
print('\tu: {}'.format(alpha['u']))
print('\tv: {}'.format(alpha['v']))
print('\tp: {}'.format(alpha['p']))
# write orders of convergence into file
file_path = os.path.join(args.directory, 'orders_of_convergence.dat')
with open(file_path, 'w') as outfile:
outfile.write('u: {}\n'.format(alpha['u']))
outfile.write('v: {}\n'.format(alpha['v']))
outfile.write('p: {}\n'.format(alpha['p']))
if args.save or args.show:
print('\nPlot the grid convergence ...')
pyplot.style.use(
os.path.join(os.environ['PETIBM_DIR'], 'scripts', 'python',
'style', 'style_PetIBM.mplstyle'))
pyplot.xlabel('grid-spacing')
pyplot.ylabel('$L_2$-norm error')
# plot errors in u-velocity
pyplot.plot([case['grid-spacing'] for case in cases],
[case['u'].error for case in cases],
label='u-velocity',
marker='o')
# plot errors in v-velocity
pyplot.plot([case['grid-spacing'] for case in cases],
[case['v'].error for case in cases],
label='v-velocity',
marker='o')
# plot errors in pressure
pyplot.plot([case['grid-spacing'] for case in cases],
[case['p'].error for case in cases],
label='pressure',
marker='o')
# plot convergence-gauge for 1st- and 2nd- orders
h = numpy.linspace(cases[0]['grid-spacing'], cases[-1]['grid-spacing'],
101)
pyplot.plot(h, h, label='$1^{st}$-order convergence', color='k')
pyplot.plot(h,
h**2,
label='$2^{nd}$-order convergence',
color='k',
linestyle='--')
pyplot.legend()
pyplot.xscale('log')
pyplot.yscale('log')
if args.save:
pyplot.savefig(os.path.join(args.directory, args.output + '.png'))
if args.show:
pyplot.show()
def main(args):
"""
Plots the grid convergence for the lid-driven cavity case.
Parameters
----------
args: namespace
Database with arguments parsed from the command-line.
"""
# initialization
simulations = sorted(
int(directory) for directory in os.listdir(args.directory)
if os.path.isdir('/'.join([args.directory, directory])))
cases = numpy.empty(len(simulations), dtype=dict)
for i, case in enumerate(cases):
cases[i] = {
'directory': '{}/{}'.format(args.directory, simulations[i]),
'grid-size': '{0}x{0}'.format(simulations[i])
}
for i, case in enumerate(cases):
directory = case['directory']
print('\n[case] grid-size: {}'.format(case['grid-size']))
# read mesh grid
grid = ioPetIBM.read_grid(directory=directory)
cases[i]['grid-spacing'] = (grid[0][-1] - grid[0][0]) / (grid[0].size -
1)
# read velocity components
cases[i]['u'], cases[i]['v'] = ioPetIBM.read_velocity(
args.time_step, grid, directory=directory)
# pressure
cases[i]['p'] = ioPetIBM.read_pressure(args.time_step,
grid,
directory=directory)
print('\nObserved order of convergence:')
last_three = True
coarse, medium, fine = cases[-3:] if last_three else cases[:3]
ratio = coarse['grid-spacing'] / medium['grid-spacing']
alpha = {
'u':
compute_order(ratio, coarse['u'].values,
restriction(medium['u'], coarse['u']).values,
restriction(fine['u'], coarse['u']).values),
'v':
compute_order(ratio, coarse['v'].values,
restriction(medium['v'], coarse['v']).values,
restriction(fine['v'], coarse['v']).values),
'p':
compute_order(ratio, coarse['p'].values,
restriction(medium['p'], coarse['p']).values,
restriction(fine['p'], coarse['p']).values)
}
print('\tu: {}'.format(alpha['u']))
print('\tv: {}'.format(alpha['v']))
print('\tp: {}'.format(alpha['p']))
# write orders of convergence into file
file_path = '{}/orders_of_convergence.dat'.format(args.directory)
with open(file_path, 'w') as outfile:
outfile.write('u: {}\n'.format(alpha['u']))
outfile.write('v: {}\n'.format(alpha['v']))
outfile.write('p: {}\n'.format(alpha['p']))
# grid convergence, comparison with finest grid
fine = cases[-1]
for i, case in enumerate(cases[:-1]):
u_fine = restriction(fine['u'], case['u'])
cases[i]['u'].error = (l2_norm(case['u'].values - u_fine.values) /
l2_norm(u_fine.values))
v_fine = restriction(fine['v'], case['v'])
cases[i]['v'].error = (l2_norm(case['v'].values - v_fine.values) /
l2_norm(v_fine.values))
p_fine = restriction(fine['p'], case['p'])
cases[i]['p'].error = (l2_norm(case['p'].values - p_fine.values) /
l2_norm(p_fine.values))
if args.save or args.show:
print('\nPlot the grid convergence ...')
pyplot.style.use(
os.path.join(os.environ['PETIBM_DIR'], 'scripts', 'python',
'style', 'style_PetIBM.mplstyle'))
pyplot.xlabel('grid-spacing')
pyplot.ylabel('$L_2$-norm error')
# plot errors in u-velocity
pyplot.plot([case['grid-spacing'] for case in cases[:-1]],
[case['u'].error for case in cases[:-1]],
label='u-velocity',
marker='o')
# plot errors in v-velocity
pyplot.plot([case['grid-spacing'] for case in cases[:-1]],
[case['v'].error for case in cases[:-1]],
label='v-velocity',
marker='o')
# plot errors in pressure
pyplot.plot([case['grid-spacing'] for case in cases[:-1]],
[case['p'].error for case in cases[:-1]],
label='pressure',
marker='o')
h = numpy.linspace(cases[0]['grid-spacing'], cases[-1]['grid-spacing'],
101)
# plot convergence-gauge for 1st- and 2nd- order
pyplot.plot(h, h, label='$1^{st}$-order convergence', color='k')
pyplot.plot(h,
h**2,
label='$2^{nd}$-order convergence',
color='k',
linestyle='--')
pyplot.legend()
pyplot.xscale('log')
pyplot.yscale('log')
if args.save:
pyplot.savefig(os.path.join(args.directory, args.output))
if args.show:
pyplot.show()
def main():
"""Plots the grid convergence for the lid-driven cavity case."""
# parse command-line
args = read_inputs()
# initialization
simulations = sorted(int(directory)
for directory in os.listdir(args.directory)
if os.path.isdir('/'.join([args.directory, directory])))
cases = numpy.empty(len(simulations), dtype=dict)
for i, case in enumerate(cases):
cases[i] = {'directory': '{}/{}'.format(args.directory, simulations[i]),
'grid-size': '{0}x{0}'.format(simulations[i])}
for i, case in enumerate(cases):
print('\n[case] grid-size: {}'.format(case['grid-size']))
# read mesh grid
grid = ioPetIBM.read_grid(case['directory'])
cases[i]['grid-spacing'] = (grid[0][-1]-grid[0][0])/(grid[0].size-1)
# read velocity components
cases[i]['u'], cases[i]['v'] = ioPetIBM.read_velocity(case['directory'],
args.time_step,
grid)
# pressure
cases[i]['p'] = ioPetIBM.read_pressure(case['directory'],
args.time_step,
grid)
print('\nObserved order of convergence:')
last_three = True
coarse, medium, fine = cases[-3:] if last_three else cases[:3]
ratio = coarse['grid-spacing']/medium['grid-spacing']
alpha = {'u': compute_order(ratio,
coarse['u'].values,
restriction(medium['u'], coarse['u']).values,
restriction(fine['u'], coarse['u']).values),
'v': compute_order(ratio,
coarse['v'].values,
restriction(medium['v'], coarse['v']).values,
restriction(fine['v'], coarse['v']).values),
'p': compute_order(ratio,
coarse['p'].values,
restriction(medium['p'], coarse['p']).values,
restriction(fine['p'], coarse['p']).values)}
print('\tu: {}'.format(alpha['u']))
print('\tv: {}'.format(alpha['v']))
print('\tp: {}'.format(alpha['p']))
# write orders of convergence into file
file_path = '{}/orders_of_convergence.dat'.format(args.directory)
with open(file_path, 'w') as outfile:
outfile.write('u: {}\n'.format(alpha['u']))
outfile.write('v: {}\n'.format(alpha['v']))
outfile.write('p: {}\n'.format(alpha['p']))
# grid convergence, comparison with finest grid
fine = cases[-1]
for i, case in enumerate(cases[:-1]):
u_fine = restriction(fine['u'], case['u'])
cases[i]['u'].error = (l2_norm(case['u'].values-u_fine.values)
/ l2_norm(u_fine.values))
v_fine = restriction(fine['v'], case['v'])
cases[i]['v'].error = (l2_norm(case['v'].values-v_fine.values)
/ l2_norm(v_fine.values))
p_fine = restriction(fine['p'], case['p'])
cases[i]['p'].error = (l2_norm(case['p'].values-p_fine.values)
/ l2_norm(p_fine.values))
if args.save or args.show:
print('\nPlot the grid convergence ...')
pyplot.style.use('{}/scripts/python/style/'
'style_PetIBM.mplstyle'.format(os.environ['PETIBM_DIR']))
pyplot.xlabel('grid-spacing')
pyplot.ylabel('$L_2$-norm error')
# plot errors in u-velocity
pyplot.plot([case['grid-spacing'] for case in cases[:-1]],
[case['u'].error for case in cases[:-1]],
label='u-velocity', marker='o')
# plot errors in v-velocity
pyplot.plot([case['grid-spacing'] for case in cases[:-1]],
[case['v'].error for case in cases[:-1]],
label='v-velocity', marker='o')
# plot errors in pressure
pyplot.plot([case['grid-spacing'] for case in cases[:-1]],
[case['p'].error for case in cases[:-1]],
label='pressure', marker='o')
h = numpy.linspace(cases[0]['grid-spacing'], cases[-1]['grid-spacing'], 101)
# plot convergence-gauge for 1st- and 2nd- order
pyplot.plot(h, h, label='$1^{st}$-order convergence', color='k')
pyplot.plot(h, h**2, label='$2^{nd}$-order convergence',
color='k', linestyle='--')
pyplot.legend()
pyplot.xscale('log')
pyplot.yscale('log')
if args.save:
pyplot.savefig('{}/{}.png'.format(args.directory, args.output))
if args.show:
pyplot.show()