def _test_functions(
self,
readscalar,
readsymmtensor,
readtensor,
readvector,
readmesh,
readarray,
):
for sol in sols:
alpha = readscalar(sol, "latestTime", "alpha")
alpha = readscalar(sol, timename, "alpha")
sigma = readsymmtensor(sol, timename, "sigma")
dummy = readsymmtensor(sol, timename, "sigmauniform")
taus = readtensor(sol, timename, "Taus")
readtensor(sol, timename, "Taus", boundary="top")
u1 = readarray(sol, timename, "U")
u = readvector(sol, "latestTime", "U")
dummy, dummy, dummy = readmesh(sol)
x, y, dummy = readmesh(sol, time_name=timename)
self.assertEqual(size, len(alpha))
self.assertEqual(3 * size, u.size)
self.assertEqual(3 * size, u1.size)
self.assertEqual(6 * size, sigma.size)
self.assertEqual(9 * size, taus.size)
for i, v in u_samples.items():
self.assertAlmostEqual(u1[i], v, places=places)
for i, v in alpha_samples.items():
self.assertAlmostEqual(v, alpha[i], places=places)
alphashort1 = readscalar("output_samples/ascii", "0", "alpha10")
readscalar("output_samples/ascii", "0", "T")
alphauniform = readscalar("output_samples/ascii", "0", "alphauniform")
readvector("output_samples/ascii", "0", "Uuniform")
alphauniform = readscalar("output_samples/bin", "0", "alphauniform")
x, y, z = readmesh("output_samples/ascii", boundary="bottom")
x, y, z = readmesh("output_samples/bin", boundary="bottom")
x, y, z = readmesh("output_samples/bin/3d")
x, y, z = readmesh("output_samples/bin/3d", boundary="bottom")
x, y, z = readmesh("output_samples/box", time_name="4")
x, y, z = readmesh("output_samples/box", time_name="3")
x, y, z = readmesh("output_samples/box", time_name="latestTime")
self.assertEqual(10, len(alphashort1))
self.assertEqual(1, len(alphauniform))
fluidfoam.readscalar("output_samples/ascii/wohead", "p")
fluidfoam.readvector("output_samples/ascii/wohead", "faceCentres")
def readOpenFoam(sol, t0, Nt, Dt, Nx, Ny, Nz, N):
tlist = t0 + np.arange(Nt) * Dt
timeRange = [(repr(item).rstrip('0')).rstrip('.') for item in tlist]
Xd, Yd, Zd = fluidfoam.readmesh(sol) # ,shape=(Nx,Ny,Nz))
toto = np.where(Xd >= 0)
shape = (Nx, Ny, Nz)
X = np.array((Nx, Ny, Nz))
Y = np.array((Nx, Ny, Nz))
# if the shape is prescribed, reshape the arrays
if (max(shape) != 1):
X = np.reshape(Xd[toto], shape, order="F")
Y = np.reshape(Yd[toto], shape, order="F")
Xp = X[:, 0, 0]
Yp = Y[0, :, 0]
time = np.zeros(Nt)
alphap = np.zeros((Nx, Ny, Nz, Nt))
ybed = np.zeros((Nx, Nt)) # bed interface
k = -1
for t in timeRange:
print("Reading time: " + str(t) + " s")
k = k + 1
alphad = fluidfoam.readscalar(sol, t + '/', 'alpha_a')
# if the shape is prescribed, reshape the arrays
if (max(shape) != 1):
alpha = np.reshape(alphad[toto], shape, order="F")
alphap[:, :, :, k] = alpha[:, :, :]
time[k] = float(t)
for i in range(Nx):
ybed[i, k] = Y[i, np.max((np.where(alphap[i, :, 0, k] > 0.57))), 0]
return alphap, Xp, Yp, tlist, ybed
def readOpenFoam(sol):
import subprocess
#
# Reading SedFoam results
#
#
proc = subprocess.Popen(['foamListTimes', '-case', sol, '-latestTime'],
stdout=subprocess.PIPE)
output = proc.stdout.read()
tread = output.rstrip() + '/'
Nt = 1
Y = fluidfoam.readscalar(sol, '0/', 'ccy')
alpha = fluidfoam.readscalar(sol, tread, 'alpha')
Ua = fluidfoam.readvector(sol, tread, 'Ua')
Ub = fluidfoam.readvector(sol, tread, 'Ub')
Tauf = fluidfoam.readtensor(sol, tread, 'Tauf')
Taus = fluidfoam.readtensor(sol, tread, 'Taus')
return Nt, Y, Ua[0, :], Ub[0, :], alpha, Tauf[1, :], Taus[1, :]
def depth(sol, t, x, y, xi, yi):
ybed = np.zeros(len(xi))
if np.mod(t, 1) == 0:
timename = str(int(t)) + '/'
else:
timename = str(t) + '/'
alpha = fluidfoam.readscalar(sol, timename, 'alpha_a')
alphai = mlab.griddata(x, y, alpha, xi, yi, interp='linear')
for j in range(len(xi) - 1):
tab = np.where(alphai[:, j+1] > 0.5)
ybed[j] = yi[np.max(tab)]
return ybed
def depth(sol, t, x, y, xi, yi):
Nx = np.size(xi, 1)
ybed = np.zeros(Nx)
if np.mod(t, 1) == 0:
timename = str(int(t)) + '/'
else:
timename = str(t) + '/'
alpha = fluidfoam.readscalar(sol, timename, 'alpha_a')
alphai = griddata((x, y), alpha, (xi, yi))
for j in range(Nx - 1):
tab = np.where(alphai[:, j + 1] > 0.5)
ybed[j] = yi[np.max(tab), j + 1]
return ybed
def readOpenFoam(sol):
import subprocess
#
# Reading SedFoam results
try:
proc = subprocess.Popen(['foamListTimes', '-latestTime', '-case', sol],
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]
Nt = 1
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')
Tauf = fluidfoam.readtensor(sol, tread, 'Taub')
Taus = fluidfoam.readtensor(sol, tread, 'Taua')
k = fluidfoam.readscalar(sol, tread, 'k.b')
Theta = fluidfoam.readscalar(sol, tread, 'Theta')
return Nt, Y, Ua[0, :], Ub[0, :], alpha, Tauf[3, :], Taus[3, :], k, Theta
###############################################################################
# Reads a scalar value at a given position for different times
# ------------------------------------------------------------
#
# .. note:: It reads the scalar field p at position 20 and stores it in the
# numpy array time_series
# import readvector function from fluidfoam package
from fluidfoam import readscalar
sol = '../output_samples/box/'
time_series = np.empty(0)
for timename in time_list:
p = readscalar(sol, timename, 'p')
time_series = np.append(time_series, p[20])
###############################################################################
# Now plots the time series
# -------------------------
#
import matplotlib.pyplot as plt
plt.figure()
# Converts strings to float for plot
time_list = [float(i) for i in time_list]
plt.plot(time_list, time_series)
theta=25 # plane slope val_p=(rhoSolid-rhoFluid)*gravity*h # pressure at the bottom timeAdim=(d/gravity)**0.5 velAdim=1000.*(gravity*d)**0.5 pressureAdim=rhoFluid*h*gravity ######################################### # Loading SedFoam results ######################################### sol = '../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', 'Ua') 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)
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]
eps_file = sol + case + '.eps'
#########################################
# 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
#########################################
# figure 1
#########################################
figure(num=1,
figsize=(figwidth, figheight),
dpi=60,
print("Do you have load OpenFoam environement?")
sys.exit(0)
output = proc.stdout.read()
tread = output.decode().rstrip().split('\n')[0]
Nx = 1
Ny = 200
Nz = 1
eps_file = sol + case + '.eps'
#
# 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')
Ny = np.size(Y)
U = np.zeros(Ny)
U = alpha[:] * Ua[0, :] + (1 - alpha[:]) * Ub[0, :]
print("max(Ub)=" + str(np.amax(Ub)) + " m/s")
#
# figure 1
#
figure(num=1,
figsize=(figwidth, figheight),
['foamListTimes', '-latestTime', '-case', sol], 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]
eps_file = sol + case + '.eps'
#########################################
# Reading SedFoam results
#########################################
X,Y,Z = fluidfoam.readmesh(sol)
alpha = fluidfoam.readscalar(sol, tread, 'alpha_a')
Ua = fluidfoam.readvector(sol, tread, 'Ua')
pa = fluidfoam.readscalar(sol, tread, 'pa')
Theta = fluidfoam.readscalar(sol, tread, 'Theta')
Ny = np.size(Y)
H = np.max(np.max(Y))
U = 1
#########################################
# figure 1
#########################################
figure(num=1, figsize=(figwidth, figheight),
dpi=60, facecolor='w', edgecolor='w')
#tread = list(output.split('\n'))
tread = output.decode().rstrip().split('\n')
del tread[-1]
Nt = len(tread)
time = np.zeros(Nt)
X, Y, Z = fluidfoam.readmesh(sol)
alphat = np.zeros((Ny, Nt))
k = -1
for t in tread:
print("Reading time: %s s" % t)
k = k + 1
alphat[:, k] = fluidfoam.readscalar(sol, t + '/', 'alpha_a')
time[k] = float(t)
#
# parameter
#
zmin = 0.
zmax = np.max(Y)
tmax = 1800.
tadj = 172.
fontsize = 18.
#
# calcul zint et zint2
sys.exit(0)
output = proc.stdout.read()
final_tread = output.decode().rstrip().split('\n')[0]
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)
proc = subprocess.Popen(
['foamListTimes', '-latestTime', '-case', sol], 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
#########################################
prec=9
X,Y,Z = fluidfoam.readmesh(sol)
alpha_0 = fluidfoam.readscalar(sol, tread, 'alpha.a')
Ua_0 = fluidfoam.readvector(sol, tread, 'U.a')
p_rbgh_0 = fluidfoam.readscalar(sol, tread, 'p_rbgh')
delta_0 = fluidfoam.readscalar(sol, tread, 'delta')
Y_list=[]
alpha_list=[]
vel_list=[]
p_rbgh_list=[]
delta_list=[]
tolAlpha=0.54
for k, alpha0k in enumerate(alpha_0):
if (alpha0k<tolAlpha):
break
Y_list.append(Y[k])
ylabel(r'$z / \delta$')
ax1.axis([-1.2, 1.2, 0, 30])
#
#
# TKE,R
#
#
i = -1
sub = [1, 3, 2, 4]
for data in datalist:
i = i + 1
print(data)
k = fluidfoam.readscalar(sol, data + '/', 'k.b')
zk = y - np.min(y)
#omega = fluidfoam.readscalar(sol, data+'/', 'omega')
#
#
#
figure(2)
ax2 = subplot(2, 2, sub[i])
pO = ax2.plot(k / U0**2, zk / delta, '--r', label="OpenFOAM")
# pO = ax2.plot(omega/U0**3,zk/delta,'-r',label="OpenFOAM")
if i == 0:
p1 = ax2.plot(TKE_phi90,
zTKE_phi90,
["foamListTimes", "-latestTime", "-case", sol],
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, 'U.a')[0]
vxFluid = fluidfoam.readvector(sol, timeStep, 'U.b')[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,
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 ngridy = 180
sol = basepath + case + '/'
#
# 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, :]
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()
except ValueError:
return False
sol = input('Nombre de la carpeta de la simulacion: ')
#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/alpha/'
x, y, z = flf.readmesh(sol, True, precision = 5)
for t in timename:
alpha = flf.readscalar(sol, t, 'alpha.water', True, precision = 5)
#Color plot
plt.figure(figsize = (5,6))
plt.title('z = 0 (m)')
plt.imshow(alpha[:,:,0].T, origin = 'lower' , extent=[np.amin(x),np.amax(x),np.amin(y),np.amax(y)])
plt.colorbar().ax.set_ylabel(r'$\alpha$')
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.tight_layout()
plt.savefig(Outdir + 'alpha_' + t + '.png')
plt.close()
# # #---------------Loading OpenFoam results-------------------- # basepath = '../' # # Loading OpenFoam results # casedir = '1DBoundaryLayer/' tout = '2500' sol = basepath + casedir x, z, y = fluidfoam.readmesh(sol) k = fluidfoam.readscalar(sol, tout, 'k') U = fluidfoam.readvector(sol, tout, 'Ub') 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)
# Reading SedFoam results
#
try:
proc = subprocess.Popen(['foamListTimes', '-withZero', '-case', sol],
stdout=subprocess.PIPE)
except:
print("foamListTimes : command not found")
print("Do you have load OpenFoam environement?")
sys.exit(0)
output = proc.stdout.read()
tread = list(output.split('\n'))
del tread[-1]
Nt = len(tread)
time = np.zeros(Nt)
Y = fluidfoam.readscalar(sol, '0/', 'ccy')
alphat = np.zeros((Ny, Nt))
k = -1
for t in tread:
print("Reading time: %s s" % t)
k = k + 1
alphat[:, k] = fluidfoam.readscalar(sol, t + '/', 'alpha')
time[k] = float(t)
#
# parameter
#
zmin = 0.
zmax = np.max(Y)
gs.update(left=0.1, right=0.95, top=0.95,bottom=0.1, wspace=0.125, hspace=0.25)
#########################################
# Reading SedFoam results
#########################################
sol='./'
proc = subprocess.Popen(
['foamListTimes', '-case', sol, '-latestTime'], stdout=subprocess.PIPE)
output = proc.stdout.read()
tread = output.decode().rstrip()
if float(tread)>1900:
tread='1900'
tread=tread+'/'
tread = '1900/'
X, Y, Z = fluidfoam.readmesh(sol)
alpha = fluidfoam.readscalar(sol, tread, 'alpha_a')
Ua = fluidfoam.readvector(sol, tread, 'Ua')
Ub = fluidfoam.readvector(sol, tread, 'Ub')
#pff = fluidfoam.readscalar(sol, tread, 'pff')
#p = fluidfoam.readscalar(sol, tread, 'p')
Ny = np.size(Y)
U = np.zeros(Ny)
U = alpha[:] * Ua[0, :] + (1 - alpha[:]) * Ub[0, :]
print("max(Ub)=" + str(np.amax(Ub)) + " m/s")
#figure(1)
#plot(Ub[0,:],Y)
#plot(uex,xex)
#show()
RMSU = RMS(Y,Ub[0,:],xex,uex)
proc = subprocess.Popen(['foamListTimes', '-latestTime', '-case', sol],
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, 'Ua')[0]
vxFluid = fluidfoam.readvector(sol, tread, 'Ub')[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)
#
# Read data over four periods and average
#
# alpha_a
if write_alpha:
rootgrp = Dataset(sol + '/postProcessing/' + case + '_alpha.nc', 'w')
rootgrp.createDimension('n', len(yi))
rootgrp.createDimension('p', n_div)
pos_file = rootgrp.createVariable('pos', np.float64, 'n')
phase_file = rootgrp.createVariable('phase', np.float64, 'p')
alpha_file = rootgrp.createVariable('alpha', np.float64, ('n', 'p'))
pos_file[:] = yi
phase_file[:] = np.linspace(0, 5, n_div)
for i, time in enumerate(time_list[1:n_div]):
alpha1 = fluidfoam.readscalar(sol, time, 'alpha_a', True, precision=12)
alpha2 = fluidfoam.readscalar(sol,
time_list[i + n_div + 1],
'alpha_a',
True,
precision=12)
alpha3 = fluidfoam.readscalar(sol,
time_list[i + 2 * n_div + 1],
'alpha_a',
True,
precision=12)
alpha4 = fluidfoam.readscalar(sol,
time_list[i + 3 * n_div + 1],
'alpha_a',
True,
precision=12)
#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/Pressure/'
x, y, z = flf.readmesh(sol, True, precision=5)
for t in timename:
P = flf.readscalar(sol, t, 'p', True, precision=5)
#Color plot
plt.figure(figsize=(5, 6))
plt.title('z = 0 (m)')
plt.imshow(P[:, :, 0].T,
origin='lower',
extent=[np.amin(x),
np.amax(x),
np.amin(y),
np.amax(y)])
plt.colorbar().ax.set_ylabel('Pressure (Pa)')
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.tight_layout()
plt.savefig(Outdir + 'P_' + t + '.png')
plt.close()
stdout=subprocess.PIPE)
output = proc.stdout.read()
tread = output.decode().rstrip() + '/'
Nx = 1
Ny = 120
Nz = 1
eps_file = sol + case + '.eps'
#########################################
# Reading SedFoam results
#########################################
X, Y, Z = fluidfoam.readmesh(sol)
alpha = fluidfoam.readscalar(sol, tread, 'alpha_a')
Ua = fluidfoam.readvector(sol, tread, 'Ua')
Ub = fluidfoam.readvector(sol, tread, 'Ub')
pff = fluidfoam.readscalar(sol, tread, 'pff')
pa = fluidfoam.readscalar(sol, tread, 'pa')
p = fluidfoam.readscalar(sol, tread, 'p')
Ny = np.size(Y)
U = np.zeros(Ny)
U = alpha[:] * Ua[0, :] + (1 - alpha[:]) * Ub[0, :]
print("max(Ub)=" + str(np.amax(Ub)) + " m/s")
#########################################
# figure 1
#########################################
proc = subprocess.Popen(['foamListTimes', '-case', sol, '-latestTime'],
stdout=subprocess.PIPE)
output = proc.stdout.read()
tread = output.rstrip() + '/'
Nx = 1
Ny = 200
Nz = 1
eps_file = sol + case + '.eps'
#########################################
# Reading SedFoam results
#########################################
Y = fluidfoam.readscalar(sol, '0/', 'ccy')
alpha = fluidfoam.readscalar(sol, tread, 'alpha')
Ua = fluidfoam.readvector(sol, tread, 'Ua')
Ub = fluidfoam.readvector(sol, tread, 'Ub')
pff = fluidfoam.readscalar(sol, tread, 'pff')
p = fluidfoam.readscalar(sol, tread, 'p')
Ny = np.size(Y)
U = np.zeros(Ny)
U = alpha[:] * Ua[0, :] + (1 - alpha[:]) * Ub[0, :]
print("max(Ub)=" + str(np.amax(Ub)) + " m/s")
#########################################
# figure 1
#########################################
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 alpha variables # import readvector and readscalar functions from fluidfoam package from fluidfoam import readvector, readscalar timename = '25' vel = readvector(sol, timename, 'Ub') alpha = readscalar(sol, timename, 'alpha') ############################################################################### # Interpolate the fields on a structured grid # ------------------------------------------- # # .. note:: The vector and scalar fields are interpolated on a specified # structured grid import numpy as np from scipy.interpolate import griddata # Number of division for linear interpolation ngridx = 500 ngridy = 180 # Interpolation grid dimensions
try:
proc = subprocess.Popen(
['foamListTimes', '-latestTime', '-case', sol], 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)
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(U.a) was not found -> postProcess -func 'grad(U.a)'")
os.system("postProcess -case "+sol+" -func \'grad(U.a)\' -time "+tread)
