'pressure': PerturbedSurface_p(),
'vel_u': AtRest(),
'vel_v': AtRest()
}
# _ _ _
# | \ | |_ _ _ __ ___ ___ _ __(_) ___ ___
# | \| | | | | '_ ` _ \ / _ \ '__| |/ __/ __|
# | |\ | |_| | | | | | | __/ | | | (__\__ \
# |_| \_|\__,_|_| |_| |_|\___|_| |_|\___|___/
# Numerics
outputStepping = tpf.OutputStepping(
final_time=0.002,
dt_init=0.001,
dt_output=0.001,
nDTout=None,
dt_fixed=0.001,
)
myTpFlowProblem = tpf.TwoPhaseFlowProblem(
ns_model=None,
ls_model=None,
nd=domain.nd,
cfl=0.4,
outputStepping=outputStepping,
structured=False,
he=he,
nnx=None,
nny=None,
nnz=None,
return min((phi_x**2 + phi_y**2)**0.5, phi_y_outflow)
class VF_IC:
def __init__(self):
self.phi = PHI_IC()
def uOfXT(self, x, t):
from proteus.ctransportCoefficients import smoothedHeaviside
return smoothedHeaviside(1.5 * opts.he, self.phi.uOfXT(x, t))
############################################
# ***** Create myTwoPhaseFlowProblem ***** #
############################################
outputStepping = TpFlow.OutputStepping(opts.final_time,
dt_output=opts.dt_output)
initialConditions = {
'pressure': zero(),
'pressure_increment': zero(),
'vel_u': zero(),
'vel_v': zero(),
'vof': VF_IC(),
'ncls': PHI_IC(),
'rdls': PHI_IC(),
'clsvof': clsvof_init_cond()
}
myTpFlowProblem = TpFlow.TwoPhaseFlowProblem(
ns_model=0,
ls_model=0,
nd=2,
mesh_fileprefix = 'mesh'
domain.MeshOptions.setOutputFiles(mesh_fileprefix)
st.assembleDomain(domain)
# _ _ _
# | \ | |_ _ _ __ ___ ___ _ __(_) ___ ___
# | \| | | | | '_ ` _ \ / _ \ '__| |/ __/ __|
# | |\ | |_| | | | | | | __/ | | | (__\__ \
# |_| \_|\__,_|_| |_| |_|\___|_| |_|\___|___/
# Numerics
outputStepping = TpFlow.OutputStepping(
final_time=T,
dt_init=dt_init,
# cfl=opts.cfl,
dt_output=sampleRate,
nDTout=None,
dt_fixed=None,
)
myTpFlowProblem = TpFlow.TwoPhaseFlowProblem(
ns_model=None,
ls_model=None,
nd=domain.nd,
cfl=cfl,
outputStepping=outputStepping,
structured=False,
he=he,
domain=domain,
initialConditions=initialConditions,
)
levelset_output=ga.PointGauges(gauges=((('phi',),PG),
),
activeTime = (0., T),
sampleRate=0.,
fileName='levelset_gauges.csv')
"""
################################ Numerics ################################
Duration = opts.Tend / opts.fract
dt_output = opts.Tt[1] / opts.Np
outputStepping = TpFlow.OutputStepping(
final_time=Duration,
dt_init=opts.dt_init,
# cfl=cfl,
dt_output=dt_output,
nDTout=None,
dt_fixed=None)
myTpFlowProblem = TpFlow.TwoPhaseFlowProblem(
ns_model=None,
ls_model=None,
nd=domain.nd,
cfl=opts.cfl,
outputStepping=outputStepping,
structured=False,
he=he,
nnx=None,
nny=None,
nnz=None,
class PHI_IC:
def uOfXT(self, x, t):
return signedDistance(x)
# ******************************* #
# ***** BOUNDARY CONDITIONS ***** #
# ******************************* #
# ADVECTIVE FLUX BOUNDARY CONDITIONS #
############################################
# ***** Create myTwoPhaseFlowProblem ***** #
############################################
outputStepping = TpFlow.OutputStepping(opts.final_time,
dt_output=opts.dt_output)
initialConditions = {
'pressure': zero(),
'pressure_increment': zero(),
'vel_u': zero(),
'vel_v': zero(),
'vel_w': zero(),
'vof': VF_IC(),
'ncls': PHI_IC(),
'rdls': PHI_IC(),
}
myTpFlowProblem = TpFlow.TwoPhaseFlowProblem(
ns_model=0,
ls_model=0,
nd=3,
def signedDistance(x, t):
#d=abs(x[1] - water_depth - water_amplitude * cos(x[0]))
d = x[1] - (water_depth + eta(x[0], t))
#d = x[1]-water_depth
return d
# _ _ _
# | \ | |_ _ _ __ ___ ___ _ __(_) ___ ___
# | \| | | | | '_ ` _ \ / _ \ '__| |/ __/ __|
# | |\ | |_| | | | | | | __/ | | | (__\__ \
# |_| \_|\__,_|_| |_| |_|\___|_| |_|\___|___/
# Numerics
myTpFlowProblem = TpFlow.TwoPhaseFlowProblem()
myTpFlowProblem.outputStepping.final_time = 0.1
myTpFlowProblem.outputStepping.dt_init = 0.01
myTpFlowProblem.outputStepping.dt_output = 0.1
myTpFlowProblem.outputStepping.dt_fixed = 0.01
myTpFlowProblem.outputStepping.archiveAllSteps = opts.archiveAllSteps
myTpFlowProblem.domain = domain
myTpFlowProblem.SystemNumerics.useSuperlu = opts.useSuperlu
myTpFlowProblem.SystemNumerics.cfl = opts.cfl
myTpFlowProblem.SystemPhysics.setDefaults()
myTpFlowProblem.SystemPhysics.useDefaultModels()
myTpFlowProblem.SystemPhysics.movingDomain = opts.movingDomain
initialConditions = {
'pressure': P_IC(),
'vel_u': AtRest(),
'vel_v': AtRest(),
'vel_w': AtRest(),
'vof': VOF_IC(),
'ncls': LS_IC(),
'rdls': LS_IC(),
}
# Two Phase Flow
dt_output = opts.Tp / opts.Np
outputStepping = TpFlow.OutputStepping(final_time=Duration,
dt_init=opts.dt_init,
dt_output=dt_output,
nDTout=None,
dt_fixed=None)
myTpFlowProblem = TpFlow.TwoPhaseFlowProblem(
ns_model=0,
ls_model=0,
nd=domain.nd,
cfl=opts.cfl,
outputStepping=outputStepping,
he=he,
domain=domain,
initialConditions=initialConditions,
)
params = myTpFlowProblem.Parameters
else:
return lambda x, t: 0.0
def ncls_AFBC(x, flag):
return None
def rdls_AFBC(x, flag):
return None
############################################
# ***** Create myTwoPhaseFlowProblem ***** #
############################################
outputStepping = TpFlow.OutputStepping(opts.final_time,
dt_output=opts.dt_output)
initialConditions = {
'pressure': zero(),
'vel_u': zero(),
'vel_v': zero(),
'vof': VF_IC(),
'ncls': PHI_IC(),
'rdls': PHI_IC()
}
boundaryConditions = {
# DIRICHLET BCs #
'pressure_DBC': pressure_DBC,
'vel_u_DBC': vel_u_DBC,
'vel_v_DBC': vel_v_DBC,
'vof_DBC': vof_DBC,
domain.geofile = mesh_fileprefix
domain.BCbyFlag[0].u_diffusive.uOfXT = lambda x, t: 0.
domain.BCbyFlag[0].v_diffusive.uOfXT = lambda x, t: 0.
# _ _ _
# | \ | |_ _ _ __ ___ ___ _ __(_) ___ ___
# | \| | | | | '_ ` _ \ / _ \ '__| |/ __/ __|
# | |\ | |_| | | | | | | __/ | | | (__\__ \
# |_| \_|\__,_|_| |_| |_|\___|_| |_|\___|___/
# Numerics
outputStepping = TpFlow.OutputStepping(
final_time=opts.T,
dt_init=opts.dt_init,
dt_output=opts.dt_output,
nDTout=None,
dt_fixed=opts.dt_fixed,
)
myTpFlowProblem = TpFlow.TwoPhaseFlowProblem(
ns_model=None,
ls_model=None,
nd=domain.nd,
cfl=opts.cfl,
outputStepping=outputStepping,
structured=False,
he=he,
nnx=None,
nny=None,
nnz=None,
if not (flag==boundaryTags['bottom'] or flag==boundaryTags['top']):
return lambda x,t: 0.0
# DIFFUSIVE FLUX #
def vel_u_DFBC(x,flag):
if not (flag==boundaryTags['bottom'] or flag==boundaryTags['top']):
return lambda x,t: 0.0
def vel_v_DFBC(x,flag):
if not (flag==boundaryTags['bottom'] or flag==boundaryTags['top']):
return lambda x,t: 0.0
############################################
# ***** Create myTwoPhaseFlowProblem ***** #
############################################
outputStepping = TpFlow.OutputStepping(opts.final_time,dt_output=opts.dt_output)
initialConditions = {'pressure': zero(),
'pressure_increment': zero(),
'vel_u': zero(),
'vel_v': zero(),
'vel_w': zero(),
'clsvof': clsvof_init_cond()}
boundaryConditions = {
# DIRICHLET BCs #
'pressure_DBC': lambda x, flag: None,
'pressure_increment_DBC': lambda x, flag: None,
'vel_u_DBC': vel_u_DBC,
'vel_v_DBC': vel_v_DBC,
'clsvof_DBC': lambda x, flag: None,
# ADVECTIVE FLUX BCs #
'pressure_AFBC': lambda x, flag: lambda x, t: 0.0,
# CLSVOF #
##########
def clsvof_DBC(x,flag):
if flag == boundaryTags['top'] and openTop:
return lambda x,t: 1.0 # let only air in
#
def clsvof_AFBC(x,flag):
if flag == boundaryTags['top'] and openTop:
return None
else:
return lambda x,t: 0.0
#
############################################
# ***** Create myTwoPhaseFlowProblem ***** #
############################################
outputStepping = TpFlow.OutputStepping(final_time,dt_output=dt_output)
initialConditions = {'pressure': zero(),
'pressure_increment': zero(),
'vel_u': vel_x_init_cond(),
'vel_v': vel_y_init_cond(),
'clsvof': clsvof_init_cond()}
boundaryConditions = {
# DIRICHLET BCs #
'pressure_DBC': pressure_DBC,
'pressure_increment_DBC': pressure_increment_DBC,
'vel_u_DBC': vel_u_DBC,
'vel_v_DBC': vel_v_DBC,
'clsvof_DBC': clsvof_DBC,
# ADVECTIVE FLUX BCs #
'pressure_AFBC': pressure_AFBC,
'pressure_increment_AFBC': pressure_increment_AFBC,
return lambda x, t: 1.0 # let only air in
#
def clsvof_AFBC(x, flag):
if flag == boundaryTags['top'] and openTop:
return None
else:
return lambda x, t: 0.0
#
############################################
# ***** Create myTwoPhaseFlowProblem ***** #
############################################
outputStepping = TpFlow.OutputStepping(opts.final_time,
dt_output=opts.dt_output)
initialConditions = {
'pressure': zero(),
'pressure_increment': zero(),
'vel_u': zero(),
'vel_v': zero(),
'vel_w': zero(),
'clsvof': clsvof_init_cond()
}
boundaryConditions = {
# DIRICHLET BCs #
'pressure_DBC': pressure_DBC,
'pressure_increment_DBC': pressure_increment_DBC,
'vel_u_DBC': vel_u_DBC,
'vel_v_DBC': vel_v_DBC,
'vel_w_DBC': vel_w_DBC,
if phi_y < 0.0:
return max(phi_x, phi_y)
else:
return phi_y
else:
if phi_y < 0.0:
return phi_x
else:
return (phi_x ** 2 + phi_y ** 2)**0.5
############################################
# ***** Create myTwoPhaseFlowProblem ***** #
############################################
outputStepping = TpFlow.OutputStepping(opts.final_time,dt_output=opts.dt_output)
initialConditions = {'pressure': zero(),
'vel_u': zero(),
'vel_v': zero(),
'vof': VF_IC(),
'ncls': PHI_IC(),
'rdls': PHI_IC(),
}
auxVariables={'vof': [height_gauges1, height_gauges2],
'pressure': [pressure_gauges]}
myTpFlowProblem = TpFlow.TwoPhaseFlowProblem(ns_model=0,
ls_model=0,
nd=2,
cfl=opts.cfl,
#########################
# ***** Numerics ****** #
#########################
#for structured
nny = int(tank_dim[1] / opts.he) + 1
nnx = int(tank_dim[0] / opts.he) + 1
#for unstructured
domain.MeshOptions.he = opts.he
st.assembleDomain(domain)
domain.MeshOptions.triangleOptions = "VApq30Dena%8.8f" % ((opts.he**2) / 2.0, )
############################################
# ***** Create myTwoPhaseFlowProblem ***** #
############################################
outputStepping = TpFlow.OutputStepping(opts.final_time,
dt_output=opts.dt_output,
dt_init=0.0001)
initialConditions = {
'pressure': zero(),
'pressure_increment': zero(),
'vel_u': zero(),
'vel_v': zero(),
'vof': VF_IC(),
'ncls': PHI_IC(),
'rdls': PHI_IC()
}
myTpFlowProblem = TpFlow.TwoPhaseFlowProblem(
ns_model=0,
ls_model=0,
nd=2,
class AtRest:
def __init__(self):
pass
def uOfXT(self, x, t):
return 0.0
# _ _ _
# | \ | |_ _ _ __ ___ ___ _ __(_) ___ ___
# | \| | | | | '_ ` _ \ / _ \ '__| |/ __/ __|
# | |\ | |_| | | | | | | __/ | | | (__\__ \
# |_| \_|\__,_|_| |_| |_|\___|_| |_|\___|___/
# Numerics
myTpFlowProblem = tpf.TwoPhaseFlowProblem()
myTpFlowProblem.domain = domain
myTpFlowProblem.outputStepping.final_time = 0.002
myTpFlowProblem.outputStepping.dt_init = 0.001
myTpFlowProblem.outputStepping.dt_output = 0.001
myTpFlowProblem.outputStepping.dt_fixed = 0.001
myTpFlowProblem.SystemPhysics.setDefaults()
myTpFlowProblem.SystemNumerics.cfl = 0.4
myTpFlowProblem.SystemNumerics.useSuperlu = False
myTpFlowProblem.SystemPhysics.movingDomain = False
params = myTpFlowProblem.SystemPhysics
