def uOfXT(self,x,t):
if useShock:
return smoothedHeaviside(epsFact_consrv_heaviside*he,shockSignedDistance(x))
else:
surfaceNormal = [-sin(self.slopeAngle),cos(self.slopeAngle)]
signedDistance = (x[0] - 0.5)*surfaceNormal[0]+(x[2] - self.waterLevel)*surfaceNormal[1]
return smoothedHeaviside(epsFact_consrv_heaviside*he,signedDistance)
def getDBC_vof(x,flag):
if altBC:
if flag in [domain.boundaryTags['downstream'],domain.boundaryTags['upstream'],domain.boundaryTags['top']]:
return lambda x,t: smoothedHeaviside(epsFact_consrv_heaviside*he,x[2]-waterLevel)
else:
if flag in [domain.boundaryTags['upstream']]:
return lambda x,t: smoothedHeaviside(epsFact_consrv_heaviside*he,x[2]-waterLevel)
if flag in [domain.boundaryTags['downstream']]:
return lambda x,t: smoothedHeaviside(epsFact_consrv_heaviside*he,x[2]-waterLevel)
def inlet_vof_dirichlet(x, t):
from proteus import Context
ct = Context.get()
level = wave.mwl + wave.eta(x,t)
mesh = ct.domain.MeshOptions
he, ecH = ct.domain.MeshOptions.he, ct.epsFact_consrv_heaviside
H = smoothedHeaviside(ecH*he,x[vert_axis]-level)
return H
def uOfXT(self,x,t):
import numpy as np
beta = epsCoupez*he
r = math.sqrt((x[0]-self.xc)**2 + (x[1]-self.yc)**2)
if ct.STABILIZATION_TYPE_ncls==0 or ct.level_set_function==0: #use dist function
return self.radius - r
else: #use saturated distance function
return beta*(2*smoothedHeaviside(beta, self.radius - r)-1)
def __cpp_calculate_smoothing_H(self, phi):
if phi >= self.smoothing:
H = 1.
elif self.smoothing > 0 and -self.smoothing < phi < self.smoothing:
H = smoothedHeaviside(self.smoothing, phi)
elif phi <= -self.smoothing:
H = 0.
return H
def getDBC_vof(x,flag):
if setWavesAtInflow:
return freeSurfaceVOF_bc
if flag in [domain.boundaryTags['top']]:
return lambda x,t: 1.0
#enforce air on right outflow boundary?
if flag in [domain.boundaryTags['right']]:
return lambda x,t: 1.0
#
if flag in [domain.boundaryTags['left']]:
return lambda x,t: smoothedHeaviside(epsFact*dy,x[1]-waterLevelBase)
def twp_flowVelocity(x, t):
from proteus import Context
ct = Context.get()
vert_axis = self.Shape.Domain.nd-1
waveHeight = self.waves.mwl+self.waves.eta(x, t)
wavePhi = x[vert_axis]-waveHeight
if wavePhi <= 0:
waterSpeed = self.waves.u(x, t)
else:
x_max = np.copy(x)
x_max[vert_axis] = waveHeight
waterSpeed = self.waves.u(x_max, t)
he, ech = ct.domain.MeshOptions.he, ct.epsFact_consrv_heaviside
H = smoothedHeaviside(0.5*ech*he, wavePhi-0.5*ech*he)
return H*self.windSpeed[i] + (1-H)*waterSpeed[i]
def ux_dirichlet(x, t):
from proteus import Context
ct = Context.get()
waveHeight = wave.mwl+wave.eta(x, t)
wavePhi = x[vert_axis]-waveHeight
if wavePhi <= 0:
waterSpeed = wave.u(x, t)
else:
x_max = list(x)
x_max[vert_axis] = waveHeight
waterSpeed = wave.u(x_max, t)
he, ecH = ct.domain.MeshOptions.he, ct.epsFact_consrv_heaviside
# smoothing only above wave, only on half the VOF smoothing length
H = smoothedHeaviside(0.5*ecH*he, wavePhi-0.5*ecH*he)
ux = H*windSpeed + (1-H)*waterSpeed
return ux[i]
def inlet_p_advective(x, t):
from proteus import Context
ct = Context.get()
# This is the normal velocity, based on the outwards boundary
# orientation b_or
# needs to be equal to -ux_dirichlet
b_or = self._b_or[self._b_i]
nd = len(b_or)
waterSpeed = np.array(wave.u(x, t))
waveHeight = wave.mwl+wave.eta(x, t)
wavePhi = x[vert_axis]-waveHeight
he = ct.domain.MeshOptions.he
if wavePhi <= 0:
waterSpeed = wave.u(x, t)
else:
x_max = list(x)
x_max[vert_axis] = waveHeight
waterSpeed = wave.u(x_max, t)
he, ecH = ct.domain.MeshOptions.he, ct.epsFact_consrv_heaviside
# smoothing only above wave, only on half the VOF smoothing length
H = smoothedHeaviside(0.5*ecH*he, wavePhi-0.5*ecH*he)
U = H*windSpeed + (1-H)*waterSpeed
u_p = np.sum(U[:nd]*b_or)
return u_p
def waveVF(x, t):
return smoothedHeaviside(epsFact_consrv_heaviside * he, wavePhi(x, t))
def uOfXT(self,x,t):
return smoothedHeaviside(epsFact_consrv_heaviside*he,x[2] - inflowHeight(t))
def twpflowVelocity_u(x, t):
waterspeed = waveVelocity_u(x, t)
H = smoothedHeaviside(epsFact_consrv_heaviside * he,
wavePhi(x, t) - epsFact_consrv_heaviside * he)
u = H * windVelocity[0] + (1.0 - H) * waterspeed
return u
def test_unsteady_two_phase_velocity_inlet(self):
from proteus.WaveTools import MonochromaticWaves
b_or = [[0., -1., 0.]]
b_i = 0
BC = create_BC(folder='mprans', b_or=b_or, b_i=b_i)
# creating a wave
period = 0.8
height = 0.029
mwl = depth = 0.9
direction = np.array([1., 0., 0.])
g = np.array([0., -9.81, 0.])
waves = MonochromaticWaves(period, height, mwl, depth, g, direction)
# need to set epsFact and he with context as they are called in BC...
ct = get_context()
from proteus.ctransportCoefficients import smoothedHeaviside
#-----
# set BC
wind_speed=np.array([1., 2., 3.4])
BC.setUnsteadyTwoPhaseVelocityInlet(waves, vert_axis=1,
wind_speed=wind_speed)
BC.getContext(ct)
BC.u_dirichlet.uOfXT = BC.u_dirichlet.init_cython()
BC.v_dirichlet.uOfXT = BC.v_dirichlet.init_cython()
BC.w_dirichlet.uOfXT = BC.w_dirichlet.init_cython()
BC.vof_dirichlet.uOfXT = BC.vof_dirichlet.init_cython()
BC.p_advective.uOfXT = BC.p_advective.init_cython()
u_dir, v_dir, w_dir, vof_dir, p_adv = [], [], [], [], []
u_calc, vof_calc, p_calc = [], [], []
t_list = get_time_array()
for t in t_list:
x = np.array(get_random_x())
u_dir += [BC.u_dirichlet.uOfXT(x, t)]
v_dir += [BC.v_dirichlet.uOfXT(x, t)]
w_dir += [BC.w_dirichlet.uOfXT(x, t)]
vof_dir += [BC.vof_dirichlet.uOfXT(x, t)]
p_adv += [BC.p_advective.uOfXT(x, t)]
# calculations
waveHeight = waves.mwl+waves.eta(x, t)
wavePhi = x[1]-waveHeight
if wavePhi <= 0:
wave_u = waves.u(x, t)
elif wavePhi > 0 and wavePhi < 0.5*ct.ecH*ct.he:
x_max = list(x)
x_max[1] = waveHeight
wave_u = waves.u(x_max, t)
else:
wave_u = np.array([0., 0., 0.])
Hu = smoothedHeaviside(0.5*ct.ecH*ct.he, wavePhi-0.5*ct.ecH*ct.he)
U = Hu*wind_speed + (1-Hu)*wave_u
u_calc += [U]
p_calc += [np.sum(U*b_or[b_i])]
Hvof = smoothedHeaviside(ct.ecH*ct.he, wavePhi)
vof_calc += [Hvof]
u_calc = np.array(u_calc)
vof_calc = np.array(vof_calc)
npt.assert_equal(BC.p_dirichlet.uOfXT, None)
npt.assert_equal(u_dir, u_calc[:, 0])
npt.assert_equal(v_dir, u_calc[:, 1])
npt.assert_equal(w_dir, u_calc[:, 2])
npt.assert_equal(vof_dir, vof_calc)
npt.assert_equal(BC.k_dirichlet.uOfXT, None)
npt.assert_equal(BC.dissipation_dirichlet.uOfXT, None)
npt.assert_equal(p_adv, p_calc)
npt.assert_equal(BC.u_advective.uOfXT, None)
npt.assert_equal(BC.v_advective.uOfXT, None)
npt.assert_equal(BC.w_advective.uOfXT, None)
npt.assert_equal(BC.vof_advective.uOfXT, None)
npt.assert_equal(BC.k_advective.uOfXT, None)
npt.assert_equal(BC.dissipation_advective.uOfXT, None)
npt.assert_equal(BC.u_diffusive.uOfXT, None)
npt.assert_equal(BC.v_diffusive.uOfXT, None)
npt.assert_equal(BC.w_diffusive.uOfXT, None)
npt.assert_equal(BC.k_diffusive.uOfXT, None)
npt.assert_equal(BC.dissipation_diffusive.uOfXT, None)
def uOfXT(self, x, t):
return smoothedHeaviside(ecH * he, signedDistance(x, 0.))
def outflowVF(x,t):
return smoothedHeaviside(epsFact_consrv_heaviside*he,x[1] - outflowHeight)
def uOfXT(self,x,t):
H=smoothedHeaviside(epsFact_consrv_heaviside*0,x[2]-waterLevel)
return H
def inflowVelocity_u(x, t):
waterspeed = inflowVelocityMean[0] + omega * amplitude * sin(
omega * t) / (k * inflowHeightMean)
H = smoothedHeaviside(epsFact_consrv_heaviside * he,
inflowPhi(x, t) - epsFact_consrv_heaviside * he)
return H * windspeed_u + (1.0 - H) * waterspeed
def uOfXT(self, x, t):
r = math.sqrt((x[0] - self.xc)**2 + (x[1] - self.yc)**2)
return smoothedHeaviside(epsFactHeaviside * he, self.radius - r)
def test_hydrostatic_pressure_outlet_with_depth(self):
from proteus.ctransportCoefficients import smoothedHeaviside, smoothedHeaviside_integral
# input
ct = get_context()
b_or = np.array([[0., -1., 0.]])
b_i = 0
seaLevel = 0.5 # m
rhoUp = 1.004e-6 # kg/m3
rhoDown = 1.500e-5 # kg/m3
g = np.array([0., -9.81, 0.]) # m/s2
refLevel = seaLevel
smoothing = 3.*0.01 # m
nd = 2
vert_axis = nd - 1
air = 1.
water = 0.
pRef = 0. # Pa
BC = create_BC(folder='mprans', b_or=b_or, b_i=b_i)
# setting variables
uDir, vDir, wDir, vofDir, pDir, uDiff, kDiff, dissDiff = [],[],[],[],[],[],[],[]
vofCalc, pCalc = [],[]
t_list = get_time_array()
BC.setHydrostaticPressureOutletWithDepth(seaLevel, rhoUp, rhoDown, g, refLevel, smoothing)
# time step iterations
for t in t_list:
x = np.array(get_random_x())
vofDir += [BC.vof_dirichlet.uOfXT(x, t)]
pDir += [BC.p_dirichlet.uOfXT(x, t)]
# Relative system of coordinates based on the point chosen as reference with pressure=pRef
phiCalc = x[vert_axis] - seaLevel
phi_top = refLevel - seaLevel
phi_ref = phi_top - phiCalc
rho_diff = rhoUp - rhoDown
phi_diff = smoothedHeaviside_integral(smoothing, phi_top) - smoothedHeaviside_integral(smoothing, phiCalc)
pTot = pRef - (g[vert_axis]*rhoDown*phi_ref) - (g[vert_axis]*rho_diff*phi_diff)
pCalc += [pTot]
# smoothing for vof activated along either the water-phase and air phase side
if phiCalc <= -smoothing:
Heav = 0.
elif -smoothing < phiCalc < smoothing:
Heav = smoothedHeaviside(smoothing, phiCalc)
else:
Heav = 1.
vofCalc += [Heav*air + (1.-Heav)*water]
# Velocity and turbulence variables
uDir += [BC.u_dirichlet.uOfXT(x, t)]
vDir += [BC.v_dirichlet.uOfXT(x, t)]
wDir += [BC.w_dirichlet.uOfXT(x, t)]
uDiff += [BC.u_diffusive.uOfXT(x, t)]
kDiff += [BC.k_diffusive.uOfXT(x, t)]
dissDiff += [BC.dissipation_diffusive.uOfXT(x, t)]
nt = len(t_list)
uCalc, vCalc, wCalc, uDiffCalc, kCalc, dissCalc = np.zeros(nt), np.zeros(nt), np.zeros(nt), np.zeros(nt), np.zeros(nt), np.zeros(nt)
npt.assert_equal(uDir, uCalc)
npt.assert_equal(vDir, vCalc)
npt.assert_equal(wDir, wCalc)
npt.assert_allclose(pDir, pCalc, atol=1e-10)
npt.assert_equal(vofDir, vofCalc)
npt.assert_equal(uDiff, uDiffCalc)
npt.assert_equal(kDiff, kCalc)
npt.assert_equal(dissDiff, dissCalc)
def outflowVel(x, t):
waterspeed = outflowVelocityMean[0]
H = smoothedHeaviside(epsFact_consrv_heaviside * he,
outflowPhi(x, t) - epsFact_consrv_heaviside * he)
u = (1.0 - H) * waterspeed
return u
def outflowVF(x, t):
return smoothedHeaviside(epsFact_consrv_heaviside * he, outflowPhi(x, t))
def uOfXT(self, x, t):
from proteus.ctransportCoefficients import smoothedHeaviside
return smoothedHeaviside(1.5 * opts.he, self.phi.uOfXT(x, 0.0))
tank.BC['airvent'].vof_dirichlet.uOfXT = lambda x, t: 1.0
tank.BC['airvent'].u_diffusive.uOfXT = lambda x, t: 0.0
tank.BC['airvent'].v_diffusive.uOfXT = lambda x, t: 0.0
#--- Initial Conditions
def wavePhi(x,t):
return x[1] - opts.waterLine_z
def outflowPhi(x,t):
return x[1] - outflow_level
def twpflowVelocity_u(x,t):
waterspeed = opts.u[0]
H = smoothedHeaviside(ecH*he,wavePhi(x,t)-ecH*he)
u = H*windVelocity[0] + (1.0-H)*waterspeed
return u
def twpflowVelocity_u_D(x, t):
waterspeed = opts.outflow_velocity
H = smoothedHeaviside(ecH * he, outflowPhi(x, t) - ecH * he)
u = H * windVelocity[0] + (1.0 - H) * waterspeed
return u
def signedDistance(x):
phi_x = x[0] - opts.waterLine_x
phi_z = x[1] - opts.waterLine_z
phi_z_outflow = x[1] - outflow_level
if phi_x <= 0.0:
if phi_z < 0.0:
class VF_IC:
def uOfXT(self, x, t):
return smoothedHeaviside(smoothing,opts.outlet_level-x[vert_axis])
def twpflowVelocity_u(x,t):
waterspeed = waveVelocity_u(x,t)
H = smoothedHeaviside(epsFact_consrv_heaviside*he,wavePhi(x,t)-epsFact_consrv_heaviside*he)
u = H*windspeed_u + (1.0-H)*waterspeed#
print x[2],u
return u
def inflowVelocity_v(x, t):
waterspeed = 0.0
H = smoothedHeaviside(epsFact_consrv_heaviside * he,
inflowPhi(x, t) - epsFact_consrv_heaviside * he)
return H * windspeed_v + (1.0 - H) * waterspeed
def waveVF(x,t):
return smoothedHeaviside(epsFact_consrv_heaviside*he,wavePhi(x,t))
def inflowVOF(x, t):
return smoothedHeaviside(epsFact_consrv_heaviside * he, inflowPhi(x, t))
def inflowVF(x, t):
return smoothedHeaviside(epsFact_consrv_heaviside * he, inflowPhi(x, t))
def uOfXT(self,x,t):
return smoothedHeaviside(self.eps,x[2] - waterLevelBase)
def test_hydrostatic_pressure_outlet_with_depth(self):
from proteus.ctransportCoefficients import smoothedHeaviside, smoothedHeaviside_integral
# input
ct = get_context()
b_or = np.array([[0., -1., 0.]])
b_i = 0
seaLevel = 0.5 # m
rhoUp = 1.004e-6 # kg/m3
rhoDown = 1.500e-5 # kg/m3
g = np.array([0., -9.81, 0.]) # m/s2
refLevel = seaLevel
smoothing = 3. * 0.01 # m
nd = 2
vert_axis = nd - 1
air = 1.
water = 0.
pRef = 0. # Pa
BC = create_BC(folder='mprans', b_or=b_or, b_i=b_i)
# setting variables
uDir, vDir, wDir, vofDir, pDir, vDiff, kDiff, dissDiff = [],[],[],[],[],[],[],[]
pInc_dir, pInit_dir = [], []
vofCalc, pCalc = [], []
t_list = get_time_array()
BC.setHydrostaticPressureOutletWithDepth(seaLevel, rhoUp, rhoDown, g,
refLevel, smoothing)
# time step iterations
for t in t_list:
x = np.array(get_random_x())
vofDir += [BC.vof_dirichlet.uOfXT(x, t)]
pDir += [BC.p_dirichlet.uOfXT(x, t)]
# Relative system of coordinates based on the point chosen as reference with pressure=pRef
phiCalc = x[vert_axis] - seaLevel
phi_top = refLevel - seaLevel
phi_ref = phi_top - phiCalc
rho_diff = rhoUp - rhoDown
phi_diff = smoothedHeaviside_integral(
smoothing, phi_top) - smoothedHeaviside_integral(
smoothing, phiCalc)
pTot = pRef - (g[vert_axis] * rhoDown *
phi_ref) - (g[vert_axis] * rho_diff * phi_diff)
pCalc += [pTot]
# smoothing for vof activated along either the water-phase and air phase side
if phiCalc <= -smoothing:
Heav = 0.
elif -smoothing < phiCalc < smoothing:
Heav = smoothedHeaviside(smoothing, phiCalc)
else:
Heav = 1.
vofCalc += [Heav * air + (1. - Heav) * water]
# Velocity and turbulence variables
uDir += [BC.u_dirichlet.uOfXT(x, t)]
vDir += [BC.v_dirichlet.uOfXT]
wDir += [BC.w_dirichlet.uOfXT(x, t)]
vDiff += [BC.v_diffusive.uOfXT(x, t)]
kDiff += [BC.k_diffusive.uOfXT(x, t)]
dissDiff += [BC.dissipation_diffusive.uOfXT(x, t)]
nt = len(t_list)
uCalc, vCalc, wCalc, vDiffCalc, kCalc, dissCalc = np.zeros(
nt), np.zeros(nt), np.zeros(nt), np.zeros(nt), np.zeros(
nt), np.zeros(nt)
npt.assert_equal(uDir, uCalc)
npt.assert_equal(BC.v_dirichlet.uOfXT, None)
npt.assert_equal(wDir, wCalc)
npt.assert_allclose(pDir, pCalc, atol=1e-10)
npt.assert_equal(vofDir, vofCalc)
npt.assert_equal(vDiff, vDiffCalc)
npt.assert_equal(kDiff, kCalc)
npt.assert_equal(dissDiff, dissCalc)
def outflowVF(x, t):
return smoothedHeaviside(epsFact_consrv_heaviside * he,
x[2] - outflowHeight)
def uOfXT(self, x, t):
return smoothedHeaviside(ct.ecH * ct.he, ct.signedDistance(x))
def outflowVF(x, t):
return smoothedHeaviside(epsFact_consrv_heaviside * he, x[2] - inflowHeightMean)
def uOfXT(self, x, t):
return smoothedHeaviside(epsFact_consrv_heaviside * he,
signedDistance(x))
def uOfXT(self,x,t):
return smoothedHeaviside(ecH*he,signedDistance(x))
def uOfXT(self, x, t):
return smoothedHeaviside(ct.epsFact_consrv_heaviside * mesh.he,
x[nd - 1] - ct.waterLevel)
def PUMI_transferFields(self):
p0 = self.pList[0].ct
n0 = self.nList[0].ct
if self.TwoPhaseFlow:
domain = p0.myTpFlowProblem.domain
rho_0 = p0.myTpFlowProblem.physical_parameters['densityA']
nu_0 = p0.myTpFlowProblem.physical_parameters[
'kinematicViscosityA']
rho_1 = p0.myTpFlowProblem.physical_parameters['densityB']
nu_1 = p0.myTpFlowProblem.physical_parameters[
'kinematicViscosityB']
g = p0.myTpFlowProblem.physical_parameters['gravity']
epsFact_density = p0.myTpFlowProblem.clsvof_parameters[
'epsFactHeaviside']
else:
domain = p0.domain
rho_0 = p0.rho_0
nu_0 = p0.nu_0
rho_1 = p0.rho_1
nu_1 = p0.nu_1
g = p0.g
epsFact_density = p0.epsFact_density
logEvent("Copying coordinates to PUMI")
domain.PUMIMesh.transferFieldToPUMI(
b"coordinates", self.modelList[0].levelModelList[0].mesh.nodeArray)
#I want to compute the density and viscosity arrays here
#arrays are length = number of elements and will correspond to density at center of element
rho_transfer = numpy.zeros(
(self.modelList[0].levelModelList[0].mesh.nElements_owned), 'd')
nu_transfer = numpy.zeros(
(self.modelList[0].levelModelList[0].mesh.nElements_owned), 'd')
#get quadrature points at element centroid and evaluate at shape functions
from proteus import Quadrature
transferQpt = Quadrature.SimplexGaussQuadrature(p0.domain.nd, 1)
qpt_centroid = numpy.asarray([transferQpt.points[0]])
materialSpace = self.nList[0].femSpaces[0](
self.modelList[0].levelModelList[0].mesh.subdomainMesh,
p0.domain.nd)
materialSpace.getBasisValuesRef(qpt_centroid)
#obtain the level-set or vof value at each element centroid
#pass through heaviside function to get material property
from proteus.ctransportCoefficients import smoothedHeaviside
IEN = self.modelList[2].levelModelList[0].u[0].femSpace.dofMap.l2g
for (eID, dofs) in enumerate(IEN):
phi_val = 0.0
for idx in range(len(dofs)):
phi_val += materialSpace.psi[0][idx] * self.modelList[
2].levelModelList[0].u[0].dof[dofs[idx]]
#rho_transfer[eID] = phi_val
#heaviside
h_phi = 0.0
for idx in range(len(dofs)):
h_phi += (materialSpace.psi[0][idx]) * (self.modelList[
2].levelModelList[0].mesh.nodeDiametersArray[dofs[idx]])
eps_rho = p0.epsFact_density * h_phi
smoothed_phi_val = smoothedHeaviside(eps_rho, phi_val)
rho_transfer[eID] = (1.0 - smoothed_phi_val) * self.pList[
0].ct.rho_0 + smoothed_phi_val * self.pList[0].ct.rho_1
nu_transfer[eID] = (1.0 - smoothed_phi_val) * self.pList[
0].ct.nu_0 + smoothed_phi_val * self.pList[0].ct.nu_1
self.modelList[0].levelModelList[0].mesh.elementMaterial = numpy.zeros(
(self.modelList[0].levelModelList[0].mesh.nElements_owned), 'd')
self.modelList[0].levelModelList[
0].mesh.elementMaterial[:] = rho_transfer[:]
#put the solution field as uList
#VOF and LS needs to reset the u.dof array for proper transfer
#but needs to be returned to the original form if not actually adapting....be careful with the following statements, unsure if this doesn't break something else
import copy
for m in self.modelList:
for lm in m.levelModelList:
lm.u_store = lm.u.copy()
for ci in range(0, lm.coefficients.nc):
lm.u_store[ci] = lm.u[ci].copy()
self.modelList[1].levelModelList[0].setUnknowns(
self.modelList[1].uList[0])
self.modelList[2].levelModelList[0].setUnknowns(
self.modelList[2].uList[0])
logEvent("Copying DOF and parameters to PUMI")
for m in self.modelList:
for lm in m.levelModelList:
coef = lm.coefficients
if coef.vectorComponents is not None:
vector = numpy.zeros((lm.mesh.nNodes_global, 3), 'd')
for vci in range(len(coef.vectorComponents)):
vector[:,
vci] = lm.u[coef.vectorComponents[vci]].dof[:]
domain.PUMIMesh.transferFieldToPUMI(
coef.vectorName.encode('utf-8'), vector)
#Transfer dof_last
for vci in range(len(coef.vectorComponents)):
vector[:, vci] = lm.u[
coef.vectorComponents[vci]].dof_last[:]
domain.PUMIMesh.transferFieldToPUMI(
coef.vectorName.encode('utf-8') + b"_old", vector)
#Transfer dof_last_last
for vci in range(len(coef.vectorComponents)):
vector[:, vci] = lm.u[
coef.vectorComponents[vci]].dof_last_last[:]
p0.domain.PUMIMesh.transferFieldToPUMI(
coef.vectorName.encode('utf-8') + b"_old_old", vector)
del vector
for ci in range(coef.nc):
if coef.vectorComponents is None or \
ci not in coef.vectorComponents:
scalar = numpy.zeros((lm.mesh.nNodes_global, 1), 'd')
scalar[:, 0] = lm.u[ci].dof[:]
domain.PUMIMesh.transferFieldToPUMI(
coef.variableNames[ci].encode('utf-8'), scalar)
#Transfer dof_last
scalar[:, 0] = lm.u[ci].dof_last[:]
domain.PUMIMesh.transferFieldToPUMI(
coef.variableNames[ci].encode('utf-8') + b"_old",
scalar)
#Transfer dof_last_last
scalar[:, 0] = lm.u[ci].dof_last_last[:]
p0.domain.PUMIMesh.transferFieldToPUMI(
coef.variableNames[ci].encode('utf-8') +
b"_old_old", scalar)
del scalar
scalar = numpy.zeros((lm.mesh.nNodes_global, 1), 'd')
del scalar
#Get Physical Parameters
#Can we do this in a problem-independent way?
rho = numpy.array([rho_0, rho_1])
nu = numpy.array([nu_0, nu_1])
g = numpy.asarray(g)
#This condition is to account for adapting before the simulation started
if (hasattr(self, "tn")):
#deltaT = self.tn-self.tn_last
#is actually the time step for next step, self.tn and self.tn_last refer to entries in tnList
#deltaT = self.systemStepController.dt_system
deltaT = self.modelList[0].levelModelList[0].timeIntegration.dtLast
T_current = self.systemStepController.t_system_last
deltaT_next = self.systemStepController.dt_system
else:
deltaT = 0
deltaT_next = 0.0
T_current = 0.0
epsFact = epsFact_density
#domain.PUMIMesh.transferPropertiesToPUMI(rho,nu,g,deltaT,epsFact)
domain.PUMIMesh.transferPropertiesToPUMI(rho_transfer, nu_transfer, g,
deltaT, deltaT_next,
T_current, epsFact)
del rho, nu, g, epsFact
def twpflowVelocity_w(x, t):
waterspeed = waveVelocity_w(x, t)
H = smoothedHeaviside(epsFact_consrv_heaviside * he,
wavePhi(x, t) - epsFact_consrv_heaviside * he)
return H * windspeed_w + (1.0 - H) * waterspeed
def twpflowVelocity_u_D(x, t):
waterspeed = outflow_velocity
H = smoothedHeaviside(ecH * he, outflowPhi(x, t) - ecH * he)
u = H * windVelocity[0] + (1.0 - H) * waterspeed
return u
def uOfX(self,X):
dx = X[0]-self.center[0]; dy = X[1]-self.center[1];
dBubble = self.radius - sqrt(dx**2 + dy**2)
return smoothedHeaviside(epsFactHeaviside*he,dBubble)#Heaviside(dBubble)
def uOfXT(self, x, t):
return smoothedHeaviside(1.5 * opts.he, signedDistance(x))
def v_current(x, t):
waterspeed = inflowVelocityMean[1]
H = smoothedHeaviside(epsFact_consrv_heaviside * he, x[2] - inflowHeightMean - epsFact_consrv_heaviside * he)
v = H * windVelocity[0] + (1.0 - H) * waterspeed
return v
def twpflowVelocity_v(x, t):
waterspeed = 0.0
H = smoothedHeaviside(epsFact_consrv_heaviside * he,
wavePhi(x, t) - epsFact_consrv_heaviside * he)
return H * windVelocity[1] + (1.0 - H) * waterspeed
def uOfXT(self, x, t):
return smoothedHeaviside(smoothing,x[nd-1]-water_level)
def uOfXT(self, x, t):
return smoothedHeaviside(opts.ecH * he, signedDistance(x))
def uOfXT(self,x,t):
return smoothedHeaviside(self.eps,x[1] - waterLevelBase)
def uOfXT(self,X,T):
return smoothedHeaviside(epsFactHeaviside*he,self.phiSol.uOfXT(X,T))#Heaviside(dBubble)
def outflowVel(x,t):
waterspeed = netcurrentVelocity
H = smoothedHeaviside(epsFact_consrv_heaviside*he,outflowPhi(x,t)-epsFact_consrv_heaviside*he)
u = (1.0-H)*waterspeed
return u
def twpflowVelocity_u(x,t):
waterspeed = inflowVelocityMean[0]
H = smoothedHeaviside(epsFact_consrv_heaviside*he,wavePhi(x,t)-epsFact_consrv_heaviside*he)
u = H*windVelocity[0] + (1.0-H)*waterspeed
return u
def twpflowVelocity_w(x,t):
waterspeed = waveVelocity_w(x,t)
H = smoothedHeaviside(epsFact_consrv_heaviside*he,wavePhi(x,t)-epsFact_consrv_heaviside*he)
w = H*windspeed_w+(1.0-H)*waterspeed
print x[2],w
return w
def uOfX(self,X):
dx = X[0]-self.center[0]; dy = X[1]-self.center[1];
dBubble = self.radius - sqrt(dx**2 + dy**2)
return smoothedHeaviside(epsFactHeaviside*he,dBubble)#Heaviside(dBubble)
def H(x,t):
return smoothedHeaviside(epsFact_consrv_heaviside*0,x[2]-waterLevel)
def uOfXT(self, x, t):
H = smoothedHeaviside(epsFact_consrv_heaviside * 0, x[2] - waterLevel)
return H
def twpflowVelocity_v(x,t):
waterspeed = waveVelocity_v(x,t)
H = smoothedHeaviside(epsFact_consrv_heaviside*he,wavePhi(x,t)-epsFact_consrv_heaviside*he)
return H*windVelocity[1]+(1.0-H)*waterspeed
def H(x, t):
return smoothedHeaviside(epsFact_consrv_heaviside * 0,
x[2] - waterLevel)
def uOfXT(self,x,t):
return smoothedHeaviside(epsFact_consrv_heaviside*he,signedDistance(x))
def test_unsteady_two_phase_velocity_inlet(self):
from proteus.WaveTools import MonochromaticWaves
b_or = np.array([[0., -1., 0.]])
b_i = 0
BC = create_BC(folder='mprans', b_or=b_or, b_i=b_i)
# creating a wave
period = 0.8
height = 0.029
mwl = depth = 0.9
direction = np.array([1., 0., 0.])
g = np.array([0., -9.81, 0.])
waves = MonochromaticWaves(period, height, mwl, depth, g, direction)
# need to set epsFact and he with context as they are called in BC...
ct = get_context()
from proteus.ctransportCoefficients import smoothedHeaviside
#-----
# set BC
wind_speed = np.array([1., 2., 3.4])
smoothing = 0.
BC.setUnsteadyTwoPhaseVelocityInlet(waves,
smoothing,
vert_axis=1,
wind_speed=wind_speed)
BC.getContext(ct)
BC.u_dirichlet.uOfXT = BC.u_dirichlet.init_cython()
BC.v_dirichlet.uOfXT = BC.v_dirichlet.init_cython()
BC.w_dirichlet.uOfXT = BC.w_dirichlet.init_cython()
BC.vof_dirichlet.uOfXT = BC.vof_dirichlet.init_cython()
BC.p_advective.uOfXT = BC.p_advective.init_cython()
BC.pInit_advective.uOfXT = BC.pInit_advective.init_cython()
u_dir, v_dir, w_dir, vof_dir, p_adv = [], [], [], [], []
pInc_adv, pInit_adv, us_dir, vs_dir,ws_dir, vof_dir, vos_dir = [], [], [], [], [],[],[]
u_calc, vof_calc, p_calc = [], [], []
k_dir, d_dir, k_dif, d_dif = [], [], [], []
t_list = get_time_array()
zeros = np.zeros(len(t_list))
for t in t_list:
x = np.array(get_random_x())
u_dir += [BC.u_dirichlet.uOfXT(x, t)]
v_dir += [BC.v_dirichlet.uOfXT(x, t)]
w_dir += [BC.w_dirichlet.uOfXT(x, t)]
k_dir += [BC.k_dirichlet.uOfXT(x, t)]
d_dir += [BC.dissipation_dirichlet.uOfXT(x, t)]
k_dif += [BC.k_diffusive.uOfXT(x, t)]
d_dif += [BC.dissipation_diffusive.uOfXT(x, t)]
us_dir += [BC.us_dirichlet.uOfXT(x, t)]
vs_dir += [BC.vs_dirichlet.uOfXT(x, t)]
ws_dir += [BC.ws_dirichlet.uOfXT(x, t)]
vof_dir += [BC.vof_dirichlet.uOfXT(x, t)]
vos_dir += [BC.vos_dirichlet.uOfXT(x, t)]
p_adv += [BC.p_advective.uOfXT(x, t)]
pInc_adv += [BC.pInc_advective.uOfXT(x, t)]
pInit_adv += [BC.pInit_advective.uOfXT(x, t)]
# calculations
waveHeight = waves.mwl + waves.eta(x, t)
wavePhi = x[1] - waveHeight
if wavePhi <= 0:
H = 0.
wave_u = waves.u(x, t)
elif smoothing > 0 and 0 < wavePhi <= smoothing:
H = smoothedHeaviside(smoothing, wavePhi - 0.5 * smoothing)
x_max = list(x)
x_max[1] = waveHeight
wave_u = waves.u(x_max, t)
else:
H = 1.
wave_u = np.array([0., 0., 0.])
U = H * wind_speed + (1 - H) * wave_u
u_calc += [U]
p_calc += [np.sum(U * b_or[b_i])]
if wavePhi >= old_div(smoothing, 2.):
Hvof = 1.
elif smoothing > 0 and -smoothing / 2. < wavePhi < smoothing / 2.:
Hvof = smoothedHeaviside(smoothing, wavePhi)
elif wavePhi <= -smoothing / 2.:
Hvof = 0.
vof_calc += [Hvof]
u_calc = np.array(u_calc)
vof_calc = np.array(vof_calc)
kInf = 1e-30 + zeros
dInf = 1e-10 + zeros
npt.assert_equal(BC.p_dirichlet.uOfXT, None)
npt.assert_equal(BC.pInc_dirichlet.uOfXT, None)
npt.assert_equal(BC.pInit_dirichlet.uOfXT, None)
npt.assert_equal(u_dir, u_calc[:, 0])
npt.assert_equal(v_dir, u_calc[:, 1])
npt.assert_equal(w_dir, u_calc[:, 2])
npt.assert_equal(us_dir, zeros)
npt.assert_equal(vs_dir, zeros)
npt.assert_equal(ws_dir, zeros)
npt.assert_equal(vof_dir, vof_calc)
npt.assert_equal(vos_dir, zeros)
npt.assert_equal(k_dir, kInf)
npt.assert_equal(d_dir, dInf)
npt.assert_equal(p_adv, p_calc)
npt.assert_equal(BC.u_advective.uOfXT, None)
npt.assert_equal(BC.v_advective.uOfXT, None)
npt.assert_equal(BC.w_advective.uOfXT, None)
npt.assert_equal(BC.us_advective.uOfXT, None)
npt.assert_equal(BC.vs_advective.uOfXT, None)
npt.assert_equal(BC.ws_advective.uOfXT, None)
npt.assert_equal(BC.vof_advective.uOfXT, None)
npt.assert_equal(BC.vos_advective.uOfXT, None)
npt.assert_equal(BC.k_advective.uOfXT, None)
npt.assert_equal(BC.dissipation_advective.uOfXT, None)
npt.assert_equal(BC.u_diffusive.uOfXT, None)
npt.assert_equal(BC.v_diffusive.uOfXT, None)
npt.assert_equal(BC.w_diffusive.uOfXT, None)
npt.assert_equal(BC.us_diffusive.uOfXT, None)
npt.assert_equal(BC.vs_diffusive.uOfXT, None)
npt.assert_equal(BC.ws_diffusive.uOfXT, None)
npt.assert_equal(k_dif, zeros)
npt.assert_equal(d_dif, zeros)
def outflowVF(x, t):
return smoothedHeaviside(epsFact_density * he, x[1] - outflowHeight)
def test_two_phase_velocity_inlet(self):
from proteus.ctransportCoefficients import smoothedHeaviside
# input
ct = get_context()
b_or = np.array([[0., -1., 0.]])
b_i = 0
U0 = [0.1, 0.2, 0.3] # m/s
waterDepth = 0.5 # m
smoothing = 3. * 0.01 # m
Uwind = [0.01, 0.02, 0.03] # m/s
vert_axis = 1 # by default alligned with the gravity
air = 1.
water = 0.
kInflow = 0.00005
dissipationInflow = 0.00001
kInflowAir = old_div(kInflow, 10.)
dissipationInflowAir = old_div(dissipationInflow, 10.)
BC = create_BC(folder='mprans', b_or=b_or, b_i=b_i)
# setting variables
uDir, vDir, wDir, vofDir, pAdv, kDir, dissipationDir = [],[],[],[],[],[],[]
uCalc, vCalc, wCalc, vofCalc, pCalc, kCalc, dissipationCalc = [],[],[],[],[],[],[]
t_list = get_time_array()
BC.setTwoPhaseVelocityInlet(U0, waterDepth, smoothing, Uwind,
vert_axis, air, water, kInflow,
dissipationInflow, kInflowAir,
dissipationInflowAir)
# time step iterations
for t in t_list:
x = np.array(get_random_x())
uDir += [BC.u_dirichlet.uOfXT(x, t)]
vDir += [BC.v_dirichlet.uOfXT(x, t)]
wDir += [BC.w_dirichlet.uOfXT(x, t)]
vofDir += [BC.vof_dirichlet.uOfXT(x, t)]
pAdv += [BC.p_advective.uOfXT(x, t)]
kDir += [BC.k_dirichlet.uOfXT(x, t)]
dissipationDir += [BC.dissipation_dirichlet.uOfXT(x, t)]
phiCalc = x[vert_axis] - waterDepth
# smoothing for velocity, kappa, dissipation field activated only along the 'air phase' side
if phiCalc <= 0.:
Heav = 0.
elif 0. < phiCalc <= smoothing:
Heav = smoothedHeaviside(smoothing, phiCalc - smoothing / 2.)
else:
Heav = 1.
u, v, w = Heav * np.array(Uwind) + (1. - Heav) * np.array(U0)
uCalc += [u]
vCalc += [v]
wCalc += [w]
up = np.sqrt((u**2) * abs(b_or[0][0]) + (v**2) * abs(b_or[0][1]) +
(w**2) * abs(b_or[0][2]))
pCalc += [-up]
kCalc += [Heav * kInflowAir + (1. - Heav) * kInflow]
dissipationCalc += [
Heav * dissipationInflowAir + (1. - Heav) * dissipationInflow
]
# smoothing for vof activated along either the water-phase and air phase side
if phiCalc <= -smoothing:
Heav = 0.
elif -smoothing < phiCalc < smoothing:
Heav = smoothedHeaviside(smoothing, phiCalc)
else:
Heav = 1.
vofCalc += [Heav * air + (1. - Heav) * water]
npt.assert_equal(uDir, uCalc)
npt.assert_equal(vDir, vCalc)
npt.assert_equal(wDir, wCalc)
npt.assert_equal(vofDir, vofCalc)
npt.assert_equal(BC.p_dirichlet.uOfXT, None)
npt.assert_equal(kDir, kCalc)
npt.assert_equal(dissipationDir, dissipationCalc)
npt.assert_equal(pAdv, pCalc)
