proc = subprocess.Popen(['foamListTimes', '-latestTime', '-case', sol], stdout=subprocess.PIPE) except: print("foamListTimes : command not found") print("Did you loaded OpenFoam environement?") sys.exit(0) output = proc.stdout.read() tread = output.decode().rstrip().split('\n')[0] ######################################### # Reading SedFoam results ######################################### X, Y, Z = fluidfoam.readmesh(sol) alpha = fluidfoam.readscalar(sol, tread, 'alpha.a') Ua = fluidfoam.readvector(sol, tread, 'U.a') Ub = fluidfoam.readvector(sol, tread, 'U.b') pff = fluidfoam.readscalar(sol, tread, 'pff') pa = fluidfoam.readscalar(sol, tread, 'pa') muI = fluidfoam.readscalar(sol, tread, 'muI') nuEffa = fluidfoam.readscalar(sol, tread, 'nuEffa') nuEffb = fluidfoam.readscalar(sol, tread, 'nuEffb') nuFra = fluidfoam.readscalar(sol, tread, 'nuFra') Tauf = fluidfoam.readtensor(sol, tread, 'Taub') Taus = fluidfoam.readtensor(sol, tread, 'Taua') try: gradUa = fluidfoam.readtensor(sol, tread, 'grad(U.a)') except: print( "grad(Ua) was not found -> Introduce - postProcess -func 'grad(U.a)' - in the command line" )
pressureAdim = rhoFluid * h * gravity ######################################### # Loading SedFoam results ######################################### sol = '../laminar/1DWetAvalanche' X, Y, Z = fluidfoam.readmesh(sol) tolAlpha = 0.55 # this part of the script analyzes the vertical profiles at time=0 (before tilting the plane) alpha_0 = fluidfoam.readscalar(sol, '200', 'alpha.a') pff_0 = fluidfoam.readscalar(sol, '200', 'pff') pa_0 = fluidfoam.readscalar(sol, '200', 'pa') p_rbgh_0 = fluidfoam.readscalar(sol, '200', 'p_rbgh') Ua_0 = fluidfoam.readvector(sol, '200', 'U.a') vel_0 = [] phi_0 = [] y_0 = [] p_excess_0 = [] p_c_0 = [] for k in range(len(alpha_0)): if (alpha_0[k] > tolAlpha): vel_0.append(Ua_0[0, k] * 1000 / velAdim) phi_0.append(alpha_0[k]) y_0.append(Y[k] / h) p_c_0.append(0) p_excess_0.append((p_rbgh_0[k] / val_p)) else:
# #---------------Loading OpenFoam results-------------------- # basepath = '../RAS/' # # Loading OpenFoam results # casedir = '1DBoundaryLayer/' tout = '2500' sol = basepath + casedir x, z, y = fluidfoam.readmesh(sol) k = fluidfoam.readscalar(sol, tout, 'k.b') U = fluidfoam.readvector(sol, tout, 'U.b') Tauf = fluidfoam.readtensor(sol, tout, 'Taub') u = U[0, :] ######################################### # # Physical parameters # rhof = 1 nu = 7.2727e-5 wallShear = np.max(Tauf[3, :]) / rhof H = np.max(z) Umax = np.max(U) Um = np.trapz(u, z) / H
stdout=subprocess.PIPE) except: print("foamListTimes : command not found") print("Do you have load OpenFoam environement?") sys.exit(0) output = proc.stdout.read() tread = output.decode().rstrip().split('\n')[0] ######################################### # Reading SedFoam results ######################################### X, Y, Z = fluidfoam.readmesh(sol) z = Y phi = fluidfoam.readscalar(sol, tread, 'alpha.a') vxPart = fluidfoam.readvector(sol, tread, 'U.a')[0] vxFluid = fluidfoam.readvector(sol, tread, 'U.b')[0] T = fluidfoam.readscalar(sol, tread, 'Theta') phi_interp = np.interp(zDATA, z, phi) rms_phi = rms(phi_interp - phiDATA) assert (rms_phi <= 0.02) vxPart_interp = np.interp(zDATA, z, vxPart) I = np.where(zDATA < 17.5 * 0.006) rms_vxP = rms(vxPart_interp[I] - vxPDATA[I]) assert (rms_vxP <= 0.1) vxFluid_interp = np.interp(zDATA, z, vxFluid) rms_vxF = rms(vxFluid_interp - vxFDATA) assert (rms_vxF <= 0.15)
# # Reading SedFoam results # tread = '16' print('########## Writing averaged data file ##########') # Read vertical coordinates x, y, z = fluidfoam.readmesh(sol, True, precision=12) ny = len(y[0, :, 0]) uny = int(ny / 2) yi = y[0, 0:uny, 0] # Read temporaly averaged variables alpha_ta = fluidfoam.readscalar(sol, tread, 'alpha_aMean', True, precision=12) ubf_ta = fluidfoam.readvector(sol, tread, 'UbMeanF', True, precision=12) uaf_ta = fluidfoam.readvector(sol, tread, 'UaMeanF', True, precision=12) ubprimf_ta = fluidfoam.readtensor(sol, tread, 'UbPrime2MeanF', True, precision=12) uaprimf_ta = fluidfoam.readtensor(sol, tread, 'UaPrime2MeanF', True, precision=12) # Usable data alpha_ta = alpha_ta[:, 0:uny, :] ubf_ta = ubf_ta[:, :, 0:uny, :]
# # # U # # i = -1 zex = np.linspace(0, h, 200) for data in datalist: i = i + 1 print(data) #ufile=basepath+data+'Uf.xy' #zu,u=np.loadtxt(ufile,unpack=True) Ub = fluidfoam.readvector(sol, data + '/', 'Ub') u = Ub[0, :] zu = y - np.min(y) figure(1) ax1 = subplot(1, 1, 1) pO = ax1.plot(u / U0, zu / delta, '--r', label="OpenFOAM") # phi="+phi[i]) if i == 0: p1 = ax1.plot(u_phi315, zu_phi315, '-b', label="Guizien et al (2003)") # phi=-45") p2 = ax1.plot(u_OW_phi315, zu_OW_phi315, '-.g', label="Wilcox") # phi=-45") p3 = ax1.plot(u_DNS_phi315, zu_DNS_phi315, ':k', label="DNS") # phi=-45")
X,Y,Z = fluidfoam.readmesh(sol) time_sim_dila_0=[] vel_sim_dila_0=[] p_sim_dila_0=[] tolAlpha=0.55 tolL=5e-4 for i in range(200,int(final_tread)): if (i % 10 ==0): time_sim_dila_0.append((i-200)/timeAdim) tread=str(i)+'/' alpha_0 = fluidfoam.readscalar(sol, tread, 'alpha_a') Ua_0 = fluidfoam.readvector(sol, tread, 'Ua') p_rbgh_0 = fluidfoam.readscalar(sol, tread, 'p_rbgh') velCol=0 P1Col=0 P2Col=0 for k in range(len(alpha_0)): if ((X[k]>-tolL) and (X[k]<tolL) and (Y[k]<h) and (Y[k]>h-tolL) and (velCol==0)): vel_sim_dila_0.append(Ua_0[0, k]*1000/velAdim) velCol=1 if (alpha_0[k]<tolAlpha and (X[k]>-tolL) and (X[k]<tolL) and (Y[k]>h) and (P1Col==0)): P1Col=1 P_surface=p_rbgh_0[k] if (alpha_0[k]>tolAlpha and (X[k]>-tolL) and (X[k]<tolL) and (Y[k]<tolL) and (P2Col==0)): P2Col=1 P_bottom=p_rbgh_0[k] if ((velCol==1) and (P1Col==1) and (P2Col==1)):
stdout=subprocess.PIPE, ) except: print("foamListTimes : command not found") print("Do you have load OpenFoam environement?") sys.exit(0) output = proc.stdout.read( ) #to obtain the output of function foamListTimes from the subprocess timeStep = output.decode().rstrip().split('\n')[ 0] #Some management on the output to obtain a number #Read the data X, Y, Z = fluidfoam.readmesh(sol) z = Y phi = fluidfoam.readscalar(sol, timeStep, 'alpha_a') vxPart = fluidfoam.readvector(sol, timeStep, 'Ua')[0] vxFluid = fluidfoam.readvector(sol, timeStep, 'Ub')[0] T = fluidfoam.readscalar(sol, timeStep, 'Theta') ###################### #Plot results ###################### d = 0.006 #6mm diameter particles plt.figure(figsize=[10, 5]) plt.subplot(141) plt.plot(phiDEM, zDEM / d, 'k--', label=r'DEM') plt.plot(phi, z / d, label=r'SedFoam') plt.xlabel(r'$\phi$', fontsize=25) plt.ylabel(r'$\frac{z}{d}$', fontsize=30, rotation=True,
This example doesn't do much, it just reads and makes a simple plot of OpenFoam field in case of files without header (as for example the output of sampling library) """ ############################################################################### # Read a scalar sampled field and the associated mesh # --------------------------------------------------- # # .. note:: It reads a scalar sampled field and the associated mesh # import readscalar, readvector function from fluidfoam package from fluidfoam import readscalar, readvector sol = '../output_samples/ascii/wohead' X, Y, Z = readvector(sol, 'faceCentres') pressure = readscalar(sol, 'p') ############################################################################### # Now plot this scalar field # -------------------------- # In this example it is the pressure coefficient around an airfoil. # It can be useful to sort the data in order to plot a line and not stars import matplotlib.pyplot as plt plt.figure() plt.plot(X, pressure, '*') plt.grid() plt.show()
Folders = glob.glob(sol + '*') timename = [] for folder in Folders: folder = folder.replace(sol, '') if isfloat(folder): if float(folder) != 0: timename.append(folder) veli = ['x', 'y', 'z'] Outdir = '' #'Figures/Vel_comp/' x, y, z = flf.readmesh(sol, True, precision=5) for t in timename: vel = flf.readvector(sol, t, 'U', True, precision=5) for i in range(3): #Color plot plt.figure(figsize=(5, 6)) plt.title('z = 0 (m)') plt.imshow(1e3 * vel[i, :, :, 0].T, origin='lower', extent=[np.amin(x), np.amax(x), np.amin(y), np.amax(y)]) plt.colorbar().ax.set_ylabel(r'$U_{%s}$' % veli[i] + r' (mm/s)') plt.xlabel('x (m)') plt.ylabel('y (m)') plt.tight_layout() plt.savefig(Outdir + 'cavity' + veli[i] + t + '.png')
#Create time list Folders = glob.glob(sol + '*') timename = [] for folder in Folders: folder = folder.replace(sol, '') if isfloat(folder): if float(folder) != 0: timename.append(folder) Outdir = '' #'Figures/Streamlines/' x, y, z = flf.readmesh(sol, True) for t in timename: vel = flf.readvector(sol, t, 'U', True) #Module of velocity. The quantity is measured transposed, according to stream plot config. V = np.sqrt(vel[0, :, :, 0].T**2 + vel[1, :, :, 0].T**2) #Color plot plt.figure(figsize=(6, 6)) plt.title('z = 0 (m)') #plt.plot(y[:,:,0],x[:,:,0],'.w') plt.streamplot(y[:, :, 0], x[:, :, 0], vel[0, :, :, 0].T, vel[1, :, :, 0].T, color=V, linewidth=2, cmap=plt.cm.viridis) plt.colorbar(fraction=0.046, pad=0.04).ax.set_ylabel('|U| (m/s)') plt.ylabel('y (m)')
nx, ny, nz = x.shape print("Nx = ", nx, "Ny = ", ny, "Nz = ", nz) ############################################################################### # Reads a vector field # -------------------- # # .. note:: It reads a vector field from a structured mesh # and stores it in vel variable # import readvector function from fluidfoam package from fluidfoam import readvector timename = '0' vel = readvector(sol, timename, 'U', structured=True) ############################################################################### # Now plots the contour of the first velocity component at a given z position # --------------------------------------------------------------------------- # # .. note:: Here the position z is the middle (// is used to have an integer) import matplotlib.pyplot as plt import numpy as np plt.figure() levels = np.arange(0, 0.178, 0.001) plt.contourf(x[:, :, nz // 2], y[:, :, nz // 2], vel[0, :, :, nz // 2],
x, y, z = readmesh(sol, True) ############################################################################### # Reads a vector field # -------------------- # # .. note:: It reads a vector field from a structured mesh # and stores it in vel variable # import readvector function from fluidfoam package from fluidfoam import readvector sol = '../output_samples/box/' timename = '0' vel = readvector(sol, timename, 'U', True) ############################################################################### # Averaging along x and z axis (1 and 3) # -------------------------------------- # import numpy as np vel_averaged = np.mean(np.mean(vel, 3), 1) ############################################################################### # Now plots the profile of the averaged first velocity component # -------------------------------------------------------------- # import matplotlib.pyplot as plt
sol = '../../output_samples/pipeline/' x, y, z = readmesh(sol) ############################################################################### # Reads vector and scalar field # ----------------------------- # # .. note:: It reads vector and scalar field from an unstructured mesh # and stores them in vel and phi variables # import readvector and readscalar functions from fluidfoam package from fluidfoam import readvector, readscalar timename = '25' vel = readvector(sol, timename, 'Ub') phi = readscalar(sol, timename, 'phi') ############################################################################### # Interpolate the fields on a structured grid # ------------------------------------------- # # .. note:: The vector and scalar fields are interpolated on a specified # structured grid # import griddata from scipy package from scipy.interpolate import griddata import numpy as np # Number of division for linear interpolation ngridx = 500
nface = x.shape print("Boundary shape = ", nface) ############################################################################### # Reads a vector field # -------------------- # # .. note:: It reads a vector field of a boundary from a structured mesh # and stores it in vel variable # import readvector function from fluidfoam package from fluidfoam import readvector timename = "0" vel = readvector(sol, timename, "U", structured=True, boundary="topWall") ############################################################################### # Now plots the contour of the first velocity component on the topWall boundary # ----------------------------------------------------------------------------- # # .. note:: Here the topWall boundary is in (x, z) plane import matplotlib.pyplot as plt import numpy as np plt.figure() levels = np.arange(0, np.max(vel[0]), 0.001) ax = plt.contourf(x[:, 0, :], z[:, 0, :], vel[0, :, 0, :], levels=levels) cbar = plt.colorbar(ax)
except: print("foamListTimes : command not found") print("Do you have load OpenFoam environement?") sys.exit(0) output = proc.stdout.read() tread = output.decode().rstrip().split('\n')[0] ######################################### # Reading SedFoam results ######################################### prec=9 X,Y,Z = fluidfoam.readmesh(sol,True,precision=prec) nx,ny,nz = X.shape alpha = fluidfoam.readscalar(sol, tread, 'alpha_a',True,precision=prec) Ua = fluidfoam.readvector(sol, tread, 'Ua',True,precision=prec) pa = fluidfoam.readscalar(sol, tread, 'pa',True,precision=prec) Theta = fluidfoam.readscalar(sol, tread, 'Theta',True,precision=prec) Ny = np.size(Y) H = np.max(np.max(Y)) U = 1 iprof=0 ######################################### # figure 1 ######################################### # ============================================================================= # figure(num=1, figsize=(figwidth, figheight),