def readMetrics(redvol, maxrad, capnum):
import matplotlib.pyplot as plt
from matplotlib.pyplot import cm
import numpy as np
from scipy import interpolate, interpolate
from math import log10, floor, pi, sqrt
import os.path
homedir = os.path.abspath(os.path.join("../../", os.pardir))
load_src("readLT", homedir + "/tools/readLT.py")
from readLT import *
###################################################
# SETUP #
###################################################
# read parameters
ifile = open("./params.in", "r")
print ifile
for line in ifile:
params = line.split() # space delimited text
if params[0] == "METRIC":
STR = params[2]
# if params[0] == 'REDVOL' :
# redvol = params[2]
# if params[0] == 'MAXRAD' :
# maxrad = params[2]
# if params[0] == 'BENMOD' :
# benmod = params[2]
# if params[0] == 'CAPNUM' :
# capnum = params[2]
ifile.close()
###################################################
# LUBRICATION THEORY #
###################################################
# load data file
# (CA, EPS, LENGTH, AREA, VLME, FX, FR, DP, GAMMAX, TAUMAX, ETA) = readLT2(homedir, redvol, maxrad)
(Ca, eps, area, vlme, s, x, r, nx, nr, tx, tr, cs, cphi, qs, p, tau, gam) = readLT(homedir, redvol, maxrad, capnum)
Dp = p[0] - p[-1]
length = max(x) - min(x)
eta = (pi * length / vlme) * (Dp / (8.0 * (1.0 - eps) * length) - 1.0)
maxgam = max(gam)
return (STR, Ca, eps, area, vlme, Dp, eta, length, maxgam)
def readMetrics(redvol,capnum) :
import matplotlib.pyplot as plt
from matplotlib.pyplot import cm
import numpy as np
from scipy import interpolate, integrate
from math import log10, floor, pi, sqrt
import os.path
homedir = os.path.abspath(os.path.join("../", os.pardir))
load_src("readLT", homedir + "/tools/readLT.py")
from readLT import *
###################################################
# SETUP #
###################################################
# read parameters
ifile = open('./params.in', 'r')
print ifile
for line in ifile :
params = line.split() # space delimited text
if params[0] == 'METRIC' :
STR = params[2]
# if params[0] == 'REDVOL' :
# redvol = params[2]
# if params[0] == 'CONFIN' :
# confin = params[2]
# if params[0] == 'BENMOD' :
# benmod = params[2]
# if params[0] == 'CAPNUM' :
# capnum = params[2]
ifile.close()
REDVOL = ['90','91','92','93','94','95','96','97','98','99','100']
REDVOL = ['80','81','82','83','84','85','86','87','88','89','90','91','92','93','94','95','96','97','98','99','100']
REDVOL = ['70','71','72','73','74','75','76','77','78','79','80','81','82','83','84','85','86','87','88','89','90','91','92','93','94','95','96','97','98','99','100']
REDVOL = ['65','66','67','68','69','70','71','72','73','74','75','76','77','78','79','80','81','82','83','84','85','86','87','88','89','90','91','92','93','94','95','96','97','98','99','100']
CONFIN = ['80','85','90','95']
CONFIN = ['95','96','97','98','99']
CONFIN = ['80','81','82','83','84','85','86','87','88','89','90','91','92','93','94','95','96','97','98','99']
#CONFIN = ['70','71','72','73','74','75','76','77','78','79','80','81','82','83','84','85','86','87','88','89','90','91','92','93','94','95','96','97','98','99',]
# CONFIN = ['80','82','84','86','88','90','92','94','96','98']
# CONFIN = ['80','85','90','95','98']
# CONFIN = ['90','91','92','93','94','95','96','97','98','99']
#CONFIN = ['99']
#CONFIN = ['99']
DP = []
EPS = []
AREA = []
VLME = []
LAMBDA = []
VOLRAT = []
for confin in CONFIN :
###################################################
# LUBRICATION THEORY #
###################################################
# load data file
#(CA, EPS, LENGTH, AREA, VLME, FX, FR, DP, GAMMAX, TAUMAX, ETA) = readLT2(homedir, redvol, confin)
(Ca, eps, area, vlme, s, x, r, nx, nr, tx, tr, cs, cphi, qs, p, tau, gam) = readLT(homedir, redvol, confin, capnum)
# alternative way of calculating the pressure drop
# - integrate the shear stress on the wall
shear = []
for i in range(len(s)) :
rr = r[i]
r2 = rr*rr
if (rr > 0.0001) :
from math import log
logr = log(rr)
g = (8.0/(1.0 - r2))
g = g*(eps - 1.0 - (1.0 - r2)/(2.0*logr))
g = g/(1.0 + r2 + (1.0 - r2)/logr)
e = 0.25*g*(2.0 + (1.0 - r2)/logr) + 1.0/logr
else :
g = 8.0*(eps - 1.0) # limiting value as r --> 0
e = 0.5*g
shear.append(-e*tx[i])
shear = np.column_stack(shear)
shear = shear[0]
dp = 2.0*integrate.trapz(shear, s)
# reduced volume
a = sqrt(area/(4.0*pi))
a3 = a*a*a
lam = a
v = vlme/((4.0/3.0)*pi*a3)
DP .append(dp)
EPS.append(eps)
AREA.append(area)
VLME.append(vlme)
LAMBDA.append(a)
VOLRAT.append(v)
DP = np.column_stack(DP)
EPS = np.column_stack(EPS)
AREA = np.column_stack(AREA)
VLME = np.column_stack(VLME)
LAMBDA = np.column_stack(LAMBDA)
VOLRAT = np.column_stack(VOLRAT)
DP = DP[0]
EPS = EPS[0]
AREA = AREA[0]
VLME = VLME[0]
LAMBDA = LAMBDA[0]
VOLRAT = VOLRAT[0]
return (STR, EPS, VOLRAT, LAMBDA, AREA, VLME, DP)
def readProfiles() :
import numpy as np
from scipy import interpolate, integrate
from math import log10, floor, pi, sqrt
import os.path
altdir = os.path.abspath("../")
load_src("readLT", altdir + "/tools/readLT.py")
from readLT import *
###################################################
# SETUP #
###################################################
# read parameters
ifile = open('./params.in', 'r')
print ifile
for line in ifile :
params = line.split() # space delimited text
if params[0] == 'PROFILE' :
STR = params[2]
if params[0] == 'REDVOL' :
redvol = params[2]
if params[0] == 'CONFIN' :
confin = params[2]
if params[0] == 'CAPNUM' :
capnum = params[2]
ifile.close()
###################################################
# LUBRICATION THEORY #
###################################################
xL = []
yL = []
vL = 0
epsL = 0
CaL = 0
# load data file
(Ca, eps, area, vlme, s, x, r, nx, nr, tx, tr, cs, cphi, qs, p, tau, gam) = readLT(altdir, redvol, confin, capnum)
lengthx = len(x)
# print lengthx
# alternative way of calculating the pressure drop
# - integrate the shear stress on the wall
shear = []
dgamds= []
for i in range(len(s)) :
rr = r[i]
r2 = rr*rr
if (rr > 0.0001) :
from math import log
logr = log(rr)
g = (8.0/(1.0 - r2))
g = g*(eps - 1.0 - (1.0 - r2)/(2.0*logr))
g = g/(1.0 + r2 + (1.0 - r2)/logr)
e = 0.25*g*(2.0 + (1.0 - r2)/logr) + 1.0/logr
e2 = 0.25*g*(2.0*rr + (1.0 - r2)/(rr*logr)) + 1.0/(rr*logr)
else :
g = 8.0*(eps - 1.0) # limiting value as r --> 0
e = 0.5*g
e2 = 0.5*g
#shear.append(-e*tx[i])
shear.append(-e)
dgamds.append(-e2)
shear = np.column_stack(shear)
shear = shear[0]
dgamds = np.column_stack(dgamds)
dgamds = dgamds[0]
dp = 2.0*integrate.trapz(shear, x)
dgam = integrate.trapz(dgamds, s)
# reflect shape across symmetry axis
xx = np.concatenate((x, np.flipud( x)))
rr = np.concatenate((r, np.flipud(-r)))
if (STR == 'SHAPE') :
xL = xx
yL = rr
elif (STR == 'PRESS') :
xL = x
yL = p
elif (STR == 'SHEAR') :
xL = x
yL = tau
# for i in range(len(tau)) :
# yL[i] = tau[i]*Ca
elif (STR == 'TENS' ) :
xL = x
yL = gam
elif (STR == 'TRANS' ) :
xL = x
yL = qs
# add a decimal point to the Ca string if need be
if (capnum[0] == '0') :
capnum = capnum[0] + '.' + capnum[1:]
a = sqrt(area/(4.0*pi))
a3 = a*a*a
v = vlme/((4.0/3.0)*pi*a3)
v = round(v, 2)
vL = v
epsL = eps
CaL = Ca
return (STR, vL, epsL, CaL, xL, yL)
def readProfiles():
import numpy as np
# from scipy import interpolate, interpolate
from math import log10, floor, pi, sqrt
import os.path
altdir = os.path.abspath("../")
load_src("readLT", altdir + "/tools/readLT.py")
from readLT import *
###################################################
# SETUP #
###################################################
# read parameters
ifile = open("./params.in", "r")
print ifile
for line in ifile:
params = line.split() # space delimited text
if params[0] == "PROFILE":
STR = params[2]
if params[0] == "REDVOL":
redvol = params[2]
if params[0] == "CONFIN":
confin = params[2]
if params[0] == "CAPNUM":
capnum = params[2]
ifile.close()
###################################################
# LUBRICATION THEORY #
###################################################
xL = []
yL = []
vL = 0
epsL = 0
CaL = 0
# load data file
(Ca, eps, area, vlme, s, x, r, nx, nr, tx, tr, cs, cphi, qs, p, tau, gam) = readLT(altdir, redvol, confin, capnum)
# lengthx = len(x)
# mid = lengthx/2
# print mid
# print (1.0 - r[mid])/eps
# print 1.0 - ((1.0 - r[mid])/eps - 1.0)*6.0/eps
# reflect shape across symmetry axis
xx = np.concatenate((x, np.flipud(x)))
rr = np.concatenate((r, np.flipud(-r)))
## interpolate to xi using splines
# tck = interpolate.splrep(x, y, s=0)
# yi = interpolate.splev(xi, tck, der=0)
if STR == "SHAPE":
xL = xx
yL = rr
elif STR == "PRESS":
xL = x
yL = p
elif STR == "SHEAR":
xL = x
yL = tau
# for i in range(len(tau)) :
# yL[i] = tau[i]*Ca
elif STR == "TENS":
xL = x
yL = gam
elif STR == "TRANS":
xL = x
yL = qs
# add a decimal point to the Ca string if need be
if capnum[0] == "0":
capnum = capnum[0] + "." + capnum[1:]
a = sqrt(area / (4.0 * pi))
a3 = a * a * a
v = vlme / ((4.0 / 3.0) * pi * a3)
v = round(v, 2)
vL = v
epsL = eps
CaL = Ca
return (STR, vL, epsL, CaL, xL, yL)
def readProfiles() :
import numpy as np
#from scipy import interpolate, interpolate
from math import log10, floor, pi, sqrt
import os.path
altdir = os.path.abspath("../../../allCa/postproc/")
altdir2 = os.path.abspath("../")
load_src("readLT", altdir + "/tools/readLT.py")
load_src("readLTHighCa", altdir2 + "/tools/readLT.py")
from readLT import *
from readLTHighCa import *
###################################################
# SETUP #
###################################################
# read parameters
ifile = open('./params.in', 'r')
print ifile
for line in ifile :
params = line.split() # space delimited text
if params[0] == 'PROFILE' :
STR = params[2]
if params[0] == 'REDVOL' :
redvol = params[2]
if params[0] == 'MAXRAD' :
maxrad = params[2]
if params[0] == 'CAPNUM' :
capnum = params[2]
ifile.close()
###################################################
# LUBRICATION THEORY #
###################################################
xL = []
yL = []
vL = 0
epsL = 0
CaL = 0
# load data file
(Ca, eps, area, vlme, s, x, r, nx, nr, tx, tr, cs, cphi, qs, p, tau, gam) = readLT(altdir, redvol, maxrad, capnum)
# reflect shape across symmetry axis
xx = np.concatenate((x, np.flipud( x)))
rr = np.concatenate((r, np.flipud(-r)))
## interpolate to xi using splines
#tck = interpolate.splrep(x, y, s=0)
#yi = interpolate.splev(xi, tck, der=0)
if (STR == 'SHAPE') :
xL = xx
yL = rr
elif (STR == 'PRESS') :
xL = x
yL = p
elif (STR == 'SHEAR') :
xL = x
yL = tau
elif (STR == 'TENS' ) :
xL = x
yL = gam
elif (STR == 'TRANS' ) :
xL = x
yL = qs
# add a decimal point to the Ca string if need be
if (capnum[0] == '0') :
capnum = capnum[0] + '.' + capnum[1:]
a = sqrt(area/(4.0*pi))
a3 = a*a*a
v = vlme/((4.0/3.0)*pi*a3)
v = round(v, 2)
vL = v
epsL = eps
CaL = Ca
###################################################
# HIGH CAPILLARY NUMBER LUBRICATION THEORY #
###################################################
xH = []
yH = []
vH = 0
epsH = 0
# load data file
(eps, area, vlme, s, x, r, nx, nr, tx, tr, cs, cphi, qs, p, tau, gam) = readLTHighCa(altdir2, redvol, maxrad)
# reflect shape across symmetry axis
xx = np.concatenate((x, np.flipud( x)))
rr = np.concatenate((r, np.flipud(-r)))
## interpolate to xi using splines
#tck = interpolate.splrep(x, y, s=0)
#yi = interpolate.splev(xi, tck, der=0)
if (STR == 'SHAPE') :
xH = xx
yH = rr
elif (STR == 'PRESS') :
xH = x
yH = p
elif (STR == 'SHEAR') :
xH = x
yH = tau
elif (STR == 'TENS' ) :
xH = x
yH = gam
elif (STR == 'TRANS' ) :
xH = x
yH = qs
a = sqrt(area/(4.0*pi))
a3 = a*a*a
v = vlme/((4.0/3.0)*pi*a3)
v = round(v, 2)
vH = v
epsH = eps
return (STR, vL, epsL, CaL, xL, yL, vH, epsH, xH, yH)
def readProfiles() :
import numpy as np
#from scipy import interpolate, interpolate
from math import log10, floor, pi, sqrt, log
import os.path
altdir = os.path.abspath("../")
load_src("readLT", altdir + "/tools/readLT.py")
from readLT import *
###################################################
# SETUP #
###################################################
# read parameters
ifile = open('./params.in', 'r')
print ifile
for line in ifile :
params = line.split() # space delimited text
if params[0] == 'PROFILE' :
STR = params[2]
if params[0] == 'REDVOL' :
redvol = params[2]
if params[0] == 'CONFIN' :
confin = params[2]
if params[0] == 'CAPNUM' :
capnum = params[2]
ifile.close()
###################################################
# LUBRICATION THEORY #
###################################################
xL = []
yL = []
vL = 0
epsL = 0
CaL = 0
# load data file
(Ca, eps, area, vlme, s, x, r, nx, nr, tx, tr, cs, cphi, qs, p, tau, gam) = readLT(altdir, redvol, confin, capnum)
tauw = []
for i in range(len(s)) :
rr = r[i]
r2 = rr*rr
if (rr > 0.0001) :
from math import log
logr = log(rr)
g = (8.0/(1.0 - r2))
g = g*(eps - 1.0 - (1.0 - r2)/(2.0*logr))
g = g/(1.0 + r2 + (1.0 - r2)/logr)
e = 0.25*g*(2.0 + (1.0 - r2)/logr) + 1.0/logr
else :
g = 8.0*(eps - 1.0) # limiting value as r --> 0
e = 0.5*g
#tauw.append(-e*tx[i])
tauw.append(e)
tauw = np.column_stack(tauw)
tauw = tauw[0]
lengthx = len(x)
mid = lengthx/2
# print mid
# print (1.0 - r[mid])/eps
# print 1.0 - ((1.0 - r[mid])/eps - 1.0)*6.0/eps
rmid = r[mid]
Q2 = eps
# print eps - (1.0 - rmid)
rmid = 0.990147
Q2 = 1.0 - rmid - (1.0/3.0)*pow((1.0 - rmid),2.0) + (1.0/4.0)*pow((1.0 - rmid),3.0)
# Q2 = 0.00983
# print 0.009821 - (1.0 - rmid + (1.0/4.0)*pow((1.0 - rmid),3.0))
print Q2
r2 = rmid*rmid
g = (8.0/(1.0 - r2))
g = g*(Q2 - 1.0 - (1.0 - r2)/(2.0*log(rmid)))
g = g/(1.0 + r2 + (1.0 - r2)/log(rmid))
print rmid
print g
# reflect shape across symmetry axis
xx = np.concatenate((x, np.flipud( x)))
rr = np.concatenate((r, np.flipud(-r)))
## interpolate to xi using splines
#tck = interpolate.splrep(x, y, s=0)
#yi = interpolate.splev(xi, tck, der=0)
if (STR == 'SHAPE') :
xL = xx
yL = rr
elif (STR == 'PRESS') :
xL = x
yL = p
elif (STR == 'SHEAR') :
xL = x
yL = tau
elif (STR == 'WALLSHEAR') :
xL = x
yL = tauw
elif (STR == 'TENS' ) :
xL = x
yL = gam
# for i in range(len(yL)):
# yL[i] = -p[i]*r[i]/gam[i]
elif (STR == 'CURV' ) :
xL = x
yL = cs
elif (STR == 'TRANS' ) :
xL = x
yL = qs
# add a decimal point to the Ca string if need be
if (capnum[0] == '0') :
capnum = capnum[0] + '.' + capnum[1:]
a = sqrt(area/(4.0*pi))
a3 = a*a*a
v = vlme/((4.0/3.0)*pi*a3)
v = round(v, 2)
vL = v
epsL = eps
CaL = Ca
###################################################
# HIGH CAPILLARY NUMBER LUBRICATION THEORY #
###################################################
xH = []
yH = []
# load data file
(eps, area, vlme, s, x, r, nx, nr, tx, tr, cs, cphi, qs, p, tau, gam) = readLTHighCa(altdir, redvol, confin)
tauw = []
for i in range(len(s)) :
rr = r[i]
r2 = rr*rr
if (rr > 0.0001) :
from math import log
logr = log(rr)
g = (8.0/(1.0 - r2))
g = g*(eps - 1.0 - (1.0 - r2)/(2.0*logr))
g = g/(1.0 + r2 + (1.0 - r2)/logr)
e = 0.25*g*(2.0 + (1.0 - r2)/logr) + 1.0/logr
else :
g = 8.0*(eps - 1.0) # limiting value as r --> 0
e = 0.5*g
#tauw.append(-e*tx[i])
tauw.append(e)
tauw = np.column_stack(tauw)
tauw = tauw[0]
# reflect shape across symmetry axis
xx = np.concatenate((x, np.flipud( x)))
rr = np.concatenate((r, np.flipud(-r)))
## interpolate to xi using splines
#tck = interpolate.splrep(x, y, s=0)
#yi = interpolate.splev(xi, tck, der=0)
if (STR == 'SHAPE') :
xH = xx
yH = rr
elif (STR == 'PRESS') :
xH = x
yH = p
elif (STR == 'SHEAR') :
xH = x
yH = tau
# for i in range(len(tau)) :
# yH[i] = -tau[i]#/(Ca)
elif (STR == 'WALLSHEAR') :
xH = x
yH = tauw
elif (STR == 'TENS' ) :
xH = x
yH = gam
# for i in range(len(yH)):
# yH[i] = -p[i]*r[i]/gam[i]
elif (STR == 'CURV' ) :
xH = x
yH = cs
elif (STR == 'TRANS' ) :
xH = x
yH = qs
return (STR, vL, epsL, CaL, xL, yL, xH, yH)