Example #1
0
def main():
	
	#view available fonts
	#for font in font_manager.findSystemFonts():
	#	print font

	try:
		fontpath = '/usr/share/fonts/truetype/msttcorefonts/Georgia.ttf'

		prop = font_manager.FontProperties(fname=fontpath)
		matplotlib.rcParams['font.family'] = prop.get_name()
	except:
		pass
	# Command line options
	parser = argparse.ArgumentParser(description="Calculates the order of convergence.", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
	parser.add_argument("-folder", dest="caseDir", help="folder in which the cases for different mesh sizes are present", default=os.path.expandvars("${CUIBM_DIR}/cases/convergence/cavityRe100/NavierStokes/20x20"))
	parser.add_argument("-tolerance", dest="tolerance", help="folder in which the cases for different mesh sizes are present", default="")
	parser.add_argument("-interpolation_type", dest="interpolation_type", help="the type of interpolation used in the direct forcing method", default="")
	parser.add_argument("-device", dest="device", help="CUDA device number", default="")
	parser.add_argument("-run", dest="runSimulations", help="run the cases if this flag is used", action='store_true', default=False)
	parser.add_argument("-remove_mask", dest="removeMask", help="use values from the entire domain", action='store_true', default=False)
	args = parser.parse_args()

	commandOptions = []
	if args.tolerance:
		commandOptions.extend(["-velocityTol", "{}".format(args.tolerance), "-poissonTol", "{}".format(args.tolerance)])
	if args.interpolation_type:
		commandOptions.extend(["-interpolationType", "{}".format(args.interpolation_type)])
	if args.device:
		commandOptions.extend(["-deviceNumber", "{}".format(args.device)])

	# list of folders from which velocity data is to be obtained
	folders = sorted(os.walk(args.caseDir).next()[1], key=int)
	numFolders = len(folders)

	# run the cases in each of the folders
	if args.runSimulations:
		for folder in folders:
			runCommand = [os.path.expandvars("${CUIBM_DIR}/bin/cuIBM"),
							'-caseFolder', "{}/{}".format(args.caseDir, folder)]
			runCommand.extend(commandOptions)
			print " ".join(runCommand)
			subprocess.call(runCommand)

	# create arrays to store the required values
	U = []
	V = []
	Q = []
	errL2NormU  = np.zeros(numFolders-1)
	errL2NormV  = np.zeros(numFolders-1)
	errL2NormQ  = np.zeros(numFolders-1)
	errLInfNormU  = np.zeros(numFolders-1)
	errLInfNormV  = np.zeros(numFolders-1)
	meshSize = np.zeros(numFolders-1, dtype=int)

	line()
	print "Case directory: {}".format(args.caseDir)
	print "Folders: ",

	stride = 1
	for fIdx, folder in enumerate(folders):
		# path to folder
		folderPath = os.path.expandvars("{}/{}".format(args.caseDir, folder));
		# read simulation information
		nt, _, _, _ = readSimulationParameters(folderPath)

		# read the grid data
		# nx and ny are the number of cells
		# dx and dy are the cell widths
		# xu and yu are the coordinates of the locations where U is calculated
		nx, ny, dx, dy, xu, yu, xv, yv = readGridData(folderPath)
		
		if fIdx==0:
			initialMeshSpacing = dx[0]
		else:
			meshSize[fIdx-1] = nx

		# read velocity data
		u, v = readVelocityData(folderPath, nt, nx, ny, dx, dy)

		if not args.removeMask:
			# read mask
			try:
				mask_u, mask_v = readMask(folderPath, nx, ny)
				u[:] = u[:]*mask_u[:]
				v[:] = v[:]*mask_v[:]
			except:
				pass

		U.append(np.reshape(u, (ny, nx-1))[stride/2::stride,stride-1::stride])
		V.append(np.reshape(v, (ny-1, nx))[stride-1::stride,stride/2::stride])
		Q.append(np.concatenate([U[fIdx].flatten(),V[fIdx].flatten()]))
		
		print '{},'.format(folder),
		stride = stride*3

	for idx in range(numFolders-1):
		errL2NormU[idx] = la.norm(U[idx+1]-U[idx])
		errL2NormV[idx] = la.norm(V[idx+1]-V[idx])
		errL2NormQ[idx] = la.norm(Q[idx+1]-Q[idx])

		errLInfNormU[idx] = la.norm(U[idx+1]-U[idx], np.inf)
		errLInfNormV[idx] = la.norm(V[idx+1]-V[idx], np.inf)
		
		if idx==0:
			plt.ioff()
			h = initialMeshSpacing
			# u diffs
			x = np.arange(0., 1.+h/2., h)
			y = np.arange(h/2., 1., h)
			X, Y = np.meshgrid(x,y)
			fig = plt.figure()
			ax = fig.add_subplot(111)
			ax.set_xlim([0,1])
			ax.set_ylim([0,1])
			diffV = np.abs(V[idx+1]-V[idx])
			ax.tick_params(labelsize=16)
			CS = ax.pcolormesh(X, Y, diffV, norm=LogNorm(vmin=1e-10, vmax=1))
			fig.gca().set_aspect('equal', adjustable='box')
			cbar = fig.colorbar(CS)
			cbar.ax.tick_params(labelsize=16) 
			if args.removeMask:
				fig.savefig("{}/diffV_nomask.pdf".format(args.caseDir))
			else:
				fig.savefig("{}/diffV.pdf".format(args.caseDir))
			# v diffs
			x = np.arange(h/2., 1., h)
			y = np.arange(0., 1.+h/2., h)
			X, Y = np.meshgrid(x,y)
			fig = plt.figure()
			ax = fig.add_subplot(111)
			ax.set_xlim([0,1])
			ax.set_ylim([0,1])
			diffU = np.abs(U[idx+1]-U[idx])
			ax.tick_params(labelsize=16)
			CS = ax.pcolormesh(X, Y, diffU, norm=LogNorm(vmin=1e-10, vmax=1))
			fig.gca().set_aspect('equal', adjustable='box')
			cbar = fig.colorbar(CS)
			cbar.ax.tick_params(labelsize=16) 
			if args.removeMask:
				fig.savefig("{}/diffU_nomask.pdf".format(args.caseDir))
			else:
				fig.savefig("{}/diffU.pdf".format(args.caseDir))

	L2OrderOfConvergenceU = -np.polyfit(np.log10(meshSize), np.log10(errL2NormU), 1)[0]
	L2OrderOfConvergenceV = -np.polyfit(np.log10(meshSize), np.log10(errL2NormV), 1)[0]
	L2OrderOfConvergenceQ = -np.polyfit(np.log10(meshSize), np.log10(errL2NormQ), 1)[0]

	LInfOrderOfConvergenceU = -np.polyfit(np.log10(meshSize), np.log10(errLInfNormU), 1)[0]
	LInfOrderOfConvergenceV = -np.polyfit(np.log10(meshSize), np.log10(errLInfNormV), 1)[0]
	
	print " "
	line()
	
	print "U:",
	#print "errL2Norms: {}".format(errL2NormU)
	print "Convergence rates:",
	for i in range(len(errL2NormU)-1):
		print "{:.3f}, ".format(np.log(errL2NormU[i]/errL2NormU[i+1])/np.log(3)),
	print "Linear fit convergence rate: {:.3f}".format(L2OrderOfConvergenceU)

	print "V:",
	#print "errL2Norms: {}".format(errL2NormV)
	print "Convergence rates:",
	for i in range(len(errL2NormV)-1):
		print "{:.3f}, ".format(np.log(errL2NormV[i]/errL2NormV[i+1])/np.log(3)),
	print "Linear fit convergence rate: {:.3f}".format(L2OrderOfConvergenceV)

	'''
	print "Q:",
	#print "errL2Norms: {}".format(errL2NormQ)
	print "Convergence rates:",
	for i in range(len(errL2NormQ)-1):
		print "{:.3f}, ".format(np.log(errL2NormQ[i]/errL2NormQ[i+1])/np.log(3)),
	print "Linear fit convergence rate: {:.3f}".format(L2OrderOfConvergenceQ)
	'''
	
	line()

	plt.clf()
	plt.loglog(meshSize, errL2NormU, 's-k', label="$u$".format(L2OrderOfConvergenceU))
	plt.loglog(meshSize, errL2NormV, 'o-k', label="$v$".format(L2OrderOfConvergenceV))
	plt.axis([1, 1e4, 1e-4, 10])
	x  = np.linspace(1, 1e4, 2)
	x1 = 1/x
	x2 = 1/x**2
	plt.loglog(x, x1, '--k', label="First-order convergence")
	plt.loglog(x, x2, ':k', label="Second-order convergence")
	plt.legend(prop={'size':15})
	ax = plt.axes()
	ax.set_xlabel("Mesh size", fontsize=18)
	ax.set_ylabel("$L^2$-norm of differences", fontsize=18)
	ax.tick_params(labelsize=18)
	plt.savefig("{}/L2Convergence.pdf".format(args.caseDir))

	'''
Example #2
0
def main():
	# Command line options
	parser = argparse.ArgumentParser(description="Calculates the order of convergence.", formatter_class=argparse.ArgumentDefaultsHelpFormatter)
	parser.add_argument("-folder", dest="caseDir", help="folder in which the cases for different mesh sizes are present", default=os.path.expandvars("${CUIBM_DIR}/cases/convergence/cavityRe100/NavierStokes/20x20"))
	parser.add_argument("-tolerance", dest="tolerance", help="folder in which the cases for different mesh sizes are present", default="")
	parser.add_argument("-interpolation_type", dest="interpolation_type", help="the type of interpolation used in the direct forcing method", default="")
	parser.add_argument("-run_simulations", dest="runSimulations", help="run the cases if this flag is used", action='store_true', default=False)
	parser.add_argument("-remove_mask", dest="removeMask", help="use values from the entire domain", action='store_true', default=False)
	args = parser.parse_args()

	commandOptions = []
	if args.tolerance:
		commandOptions.extend(["-velocityTol", "{}".format(args.tolerance), "-poissonTol", "{}".format(args.tolerance)])
	if args.interpolation_type:
		commandOptions.extend(["-interpolationType", "{}".format(args.interpolation_type)])

	# list of folders from which velocity data is to be obtained
	folders = sorted(os.walk(args.caseDir).next()[1], key=int)
	numFolders = len(folders)

	# run the cases in each of the folders
	if args.runSimulations:
		for folder in folders:
			runCommand = [os.path.expandvars("${CUIBM_DIR}/bin/cuIBM"),
							'-caseFolder', "{}/{}".format(args.caseDir, folder)]
			runCommand.extend(commandOptions)
			print " ".join(runCommand)
			subprocess.call(runCommand)

	# create arrays to store the required values
	U = []
	V = []
	errL2NormU  = np.zeros(numFolders-1)
	errL2NormV  = np.zeros(numFolders-1)
	errLInfNormU  = np.zeros(numFolders-1)
	errLInfNormV  = np.zeros(numFolders-1)
	meshSize = np.zeros(numFolders-1, dtype=int)

	line()

	stride = 1
	for fIdx, folder in enumerate(folders):
		# path to folder
		folderPath = os.path.expandvars("{}/{}".format(args.caseDir, folder));
		# read simulation information
		nt, _, _, _ = readSimulationParameters(folderPath)

		# read the grid data
		# nx and ny are the number of cells
		# dx and dy are the cell widths
		# xu and yu are the coordinates of the locations where U is calculated
		nx, ny, dx, dy, xu, yu, xv, yv = readGridData(folderPath)
		
		if fIdx==0:
			initialMeshSpacing = dx[0]
		else:
			meshSize[fIdx-1] = nx

		# read velocity data
		u, v = readVelocityData(folderPath, nt, nx, ny, dx, dy)

		if not args.removeMask:
			# read mask
			mask_u, mask_v = readMask(folderPath, nx, ny)
			u[:] = u[:]*mask_u[:]
			v[:] = v[:]*mask_v[:]

		U.append(np.reshape(u, (ny, nx-1))[stride/2::stride,stride-1::stride])
		V.append(np.reshape(v, (ny-1, nx))[stride-1::stride,stride/2::stride])
		
		print 'Completed folder {}. u:{}, v:{}'.format(folder, U[fIdx].shape, V[fIdx].shape)
		stride = stride*3

	for idx in range(numFolders-1):
		errL2NormU[idx] = la.norm(U[idx+1]-U[idx])
		errL2NormV[idx] = la.norm(V[idx+1]-V[idx])

		errLInfNormU[idx] = la.norm(U[idx+1]-U[idx], np.inf)
		errLInfNormV[idx] = la.norm(V[idx+1]-V[idx], np.inf)
		
		if idx==0:
			h = initialMeshSpacing
			x = np.arange(h/2., 1., h)
			y = np.arange(h, 1., h)
			X, Y = np.meshgrid(x,y)
			plt.ioff()
			fig = plt.figure()
			ax = fig.add_subplot(111)
			diffV = np.abs(V[idx+1]-V[idx] )
			CS = ax.pcolor(X, Y, diffV, norm=LogNorm(vmin=1e-10, vmax=1))
			fig.gca().set_aspect('equal', adjustable='box')
			fig.colorbar(CS)
			if args.removeMask:
				fig.savefig("{}/diff_nomask.png".format(args.caseDir))
			else:
				fig.savefig("{}/diff.png".format(args.caseDir))
	
	L2OrderOfConvergenceU = -np.polyfit(np.log10(meshSize), np.log10(errL2NormU), 1)[0]
	L2OrderOfConvergenceV = -np.polyfit(np.log10(meshSize), np.log10(errL2NormV), 1)[0]

	LInfOrderOfConvergenceU = -np.polyfit(np.log10(meshSize), np.log10(errLInfNormU), 1)[0]
	LInfOrderOfConvergenceV = -np.polyfit(np.log10(meshSize), np.log10(errLInfNormV), 1)[0]
	
	line()
	print "Mesh sizes: {}".format(meshSize)
	line()
	print "U:"
	print "errL2Norms: {}".format(errL2NormU)
	print "Convergence rates: {:.3f}, {:.3f}".format(np.log(errL2NormU[0]/errL2NormU[1])/np.log(3), np.log(errL2NormU[1]/errL2NormU[2])/np.log(3))
	print "Linear fit convergence rate: {:.3f}".format(L2OrderOfConvergenceU)

	print "\nV:"
	print "errL2Norms: {}".format(errL2NormV)
	print "Convergence rates: {:.3f}, {:.3f}".format(np.log(errL2NormV[0]/errL2NormV[1])/np.log(3), np.log(errL2NormV[1]/errL2NormV[2])/np.log(3))
	print "Linear fit convergence rate: {:.3f}".format(L2OrderOfConvergenceV)
	
	plt.clf()
	plt.loglog(meshSize, errL2NormU, 'o-b', label="L-2 norm of difference in $u$\nOrder of convergence={:.3f}".format(L2OrderOfConvergenceU))
	plt.loglog(meshSize, errL2NormV, 'o-r', label="L-2 norm of difference in $v$\nOrder of convergence={:.3f}".format(L2OrderOfConvergenceV))
	plt.axis([1, 1e4, 1e-4, 100])
	x  = np.linspace(1, 1e4, 2)
	x1 = 1/x
	x2 = 1/x**2
	plt.loglog(x, x1, '--k', label="First-order convergence")
	plt.loglog(x, x2, ':k', label="Second-order convergence")
	plt.legend()
	ax = plt.axes()
	ax.set_xlabel("Mesh size")
	ax.set_ylabel("L-2 Norm of difference between solutions on consecutive grids")
	plt.savefig("{}/L2Convergence.png".format(args.caseDir))

	line()
	print "U:"
	print "errLInfNorms: {}".format(errLInfNormU)
	print "Convergence rates: {:.3f}, {:.3f}".format(np.log(errLInfNormU[0]/errLInfNormU[1])/np.log(3), np.log(errLInfNormU[1]/errLInfNormU[2])/np.log(3))
	print "Linear fit convergence rate: {:.3f}".format(LInfOrderOfConvergenceU)

	print "\nV:"
	print "errLInfNorms: {}".format(errLInfNormV)
	print "Convergence rates: {:.3f}, {:.3f}".format(np.log(errLInfNormV[0]/errLInfNormV[1])/np.log(3), np.log(errLInfNormV[1]/errLInfNormV[2])/np.log(3))
	print "Linear fit convergence rate: {:.3f}".format(LInfOrderOfConvergenceV)
	line()

	plt.clf()
	plt.loglog(meshSize, errLInfNormU, 'o-b', label="L-Inf norm of difference in $u$\nOrder of convergence={:.3f}".format(LInfOrderOfConvergenceU))
	plt.loglog(meshSize, errLInfNormV, 'o-r', label="L-Inf norm of difference in $v$\nOrder of convergence={:.3f}".format(LInfOrderOfConvergenceV))
	plt.axis([1, 1e4, 1e-4, 100])
	x  = np.linspace(1, 1e4, 2)
	x1 = 1/x
	x2 = 1/x**2
	plt.loglog(x, x1, '--k', label="First-order convergence")
	plt.loglog(x, x2, ':k', label="Second-order convergence")
	plt.legend()
	ax = plt.axes()
	ax.set_xlabel("Mesh size")
	ax.set_ylabel("L-Inf Norm of difference between solutions on consecutive grids")
	plt.savefig("{}/LInfConvergence.png".format(args.caseDir))