def test_import():
"""
Test the import from the xdmf file.
"""
# Get the current directory
current_dir = "{}/{}".format(os.getcwd(), "test/import")
# Run the import
mesh, boundaries, subdomains, labels = import_mesh_from_xdmf(
domain="multidomain_domain.xdmf",
boundaries="multidomain_boundaries.xdmf",
labels="multidomain_labels.yml",
dim=2,
directory=current_dir,
subdomains=True,
)
def test_import():
"""
Test the import from the xdmf file.
"""
# Get the current directory
current_dir = "{}/{}".format(os.getcwd(), "test/import")
# Run the import
mesh, boundaries, subdomains, labels = import_mesh_from_xdmf(
prefix="multidomain",
dim=2,
directory=current_dir,
subdomains=True,
)
# Check if the labels are correct
assert (labels["top_domain"] == 1)
assert (labels["bot_domain"] == 2)
assert (labels["middle"] == 3)
assert (labels["right"] == 4)
assert (labels["top"] == 5)
assert (labels["bot"] == 6)
assert (labels["left"] == 7)
def inside(self, x, on_boundary):
return on_boundary and x[0] > DOLFIN_EPS and near(x[1], 0)
# Taking right side of semicircle boundary as original "target domain"
def map(
self, x, y
): # Mapping to new boundary, w/ same conditions for negative part of x-axis
y[0] = -x[0]
y[1] = x[1]
domain_bound = Domain_Boundary(
) # Far-Field Boundary Condition (approaches zero)
semicircle_bound = Periodic_Boundary() # Periodic Boundary Conditions
# -------------------------------------------------------------------------------------------
mesh, boundaries_mf, subdomains_mf, association_table = import_mesh_from_xdmf(
prefix="motor_mesh", dim=2, subdomains=True)
# boundaries_mf: Mesh Function object for boundaries
# subdomains_mf: Mesh Function object for subdomains
V = FunctionSpace(mesh, 'P', 1, constrained_domain=Periodic_Boundary())
dx = Measure('dx', domain=mesh, subdomain_data=subdomains_mf)
'''
Domain list for dx:
Rotor Core: 1
Stator Core: 2
Outer Motor Domain: 3
Inner Motor Domain: 4
Middle Air Gap: 5
Right Air Slot Domains (next to magnet): 6 to 13
Left Air Slot Domains (next to magnet): 14 to 21
def sim_flow(u_0, nu, cp, k, p_0, T_0, fileName, Le, He, We):
# LOAD MESH
mesh, boundaries, association_table = import_mesh_from_xdmf(
prefix=fileName, dim=3)
# Build function space
P2 = VectorElement('Lagrange', mesh.ufl_cell(), 2)
P1 = FiniteElement('Lagrange', mesh.ufl_cell(), 1)
element = MixedElement([P2, P1, P1])
W = FunctionSpace(mesh, element)
#define test and trial functions
(v, q, s) = TestFunctions(W)
#split functions
upT = Function(W)
# Define initial conditions
e_u0 = Expression(('0.', '0.', 'u0'), u0=Constant(u_0), degree=1)
e_p0 = Expression('0.', degree=1)
e_T0 = Expression('0.', degree=1)
u0 = interpolate(e_u0, W.sub(0).collapse())
p0 = interpolate(e_p0, W.sub(1).collapse())
T0 = interpolate(e_T0, W.sub(2).collapse())
assign(upT, [u0, p0, T0])
(u, p, T) = split(upT)
n = FacetNormal(mesh)
h = CellDiameter(mesh)
# Define boundary conditions
# FLOW
# Define inflow profile from Shah & London 1976 (velocity profile in a rectangular duct)
alpha = min(We / He, He / We) # <1
mv = 1.7 + 0.5 * alpha**-1.4
if alpha <= 1. / 3.:
nv = 2
else:
nv = 2 + 0.3 * (alpha - 1. / 3.)
Umax = u_0 * (mv + 1) / mv * (nv + 1) / nv
print("alpha, m, n, Umax = ", alpha, mv, nv, Umax)
inflow_profile = (
'0', '0',
'Umax * (1. - pow(abs(x[0]/H*2), n)) * (1. - pow(abs(x[1]/W*2), m))')
inflow_profile = Expression(inflow_profile,
Umax=Constant(Umax),
H=Constant(He),
W=Constant(We),
m=Constant(mv),
n=Constant(nv),
degree=2)
bcu_inflow = DirichletBC(W.sub(0), inflow_profile, boundaries,
association_table["inlet"])
bcu_noslip = DirichletBC(W.sub(0), Constant((0, 0, 0)), boundaries,
association_table["noslip"])
bcu_outflow = DirichletBC(W.sub(1), Constant(p_0), boundaries,
association_table["outlet"])
bcu = [bcu_inflow, bcu_noslip, bcu_outflow]
# ENERGY
bcT_inflow = DirichletBC(W.sub(2), Constant(T_0), boundaries,
association_table["inlet"])
bcT_noslip = DirichletBC(W.sub(2), Constant(Tw), boundaries,
association_table["noslip"])
bcT = [bcT_inflow, bcT_noslip]
bcs = bcu + bcT
# DEFINE WEAK VARIATIONAL FORM
F1 = (
rho * inner(grad(u) * u, v) * dx + # Momentum ddvection term
mu * inner(grad(u), grad(v)) * dx - # Momentum diffusion term
inner(p, div(v)) * dx + # Pressure term
div(u) * q * dx # Divergence term
)
F2 = (
rho * cp * inner(dot(grad(T), u), s) * dx + # Energy advection term
k * inner(grad(T), grad(s)) * dx # Energy diffusion term
)
F = F1 + F2
"""
# STABILIZATION
dx2 = dx(metadata={"quadrature_degree":2*3})
F1 = (rho*inner(grad(u)*u, v)*dx2 + # Momentum advection term
mu*inner(grad(u), grad(v))*dx2 - # Momentum diffusion term
inner(p, div(v))*dx2 + # Pressure term
div(u)*q*dx2 # Divergence term
)
F2 = (k*inner(grad(T), grad(s))*dx2 + # Energy advection term
rho*cp*inner(dot(grad(T), u), s)*dx2 # Energy diffusion term
)
F = F1 + F2
# SUPG / PSPG
sigma = 2.*mu*sym(grad(u)) - p*Identity(len(u))
# Strong formulation:
res_strong = rho*dot(u, grad(u)) - div(sigma)
Cinv = Constant(16*Re) # --> 16*Re is rather high, but solver diverges for lower values
vnorm = sqrt(dot(u, u))
tau_SUPG = Min(h**2/(Cinv*nu), h/(2.*vnorm))
F_SUPG = inner(tau_SUPG*res_strong, rho*dot(grad(v),u))*dx2 # Includes PSPG
F = F + F_SUPG
# LSIC/grad-div:
#tau_LSIC = rho * 2*nu/3
tau_LSIC = h**2/tau_SUPG
F_LSIC = tau_LSIC*div(u)*div(v)*dx2
F = F + F_LSIC
# Energy stabilization
# Strong formulation:
res_strong = rho*cp*dot(u, grad(T)) - k*div(grad(T))
#vnorm = sqrt(dot(u, u))
#Cinv = Constant(16*2**2)
#Cinv = Constant(16*Re)
#tau_E = Min(h**2/(Cinv*nu), h/(2.*vnorm))
tau_E = h**2 * (rho*cp/k) / 1000.
F_E = inner(tau_E*res_strong, rho*cp*dot(u,grad(s)))*dx2
F = F + F_E
"""
# Create VTK files for visualization output
vtkfile_u = File('results/u.pvd')
vtkfile_p = File('results/p.pvd')
vtkfile_T = File('results/T.pvd')
J = derivative(F, upT) # Jacobian
problem = NonlinearVariationalProblem(F, upT, bcs, J)
solver = NonlinearVariationalSolver(problem)
prm = solver.parameters
prm['nonlinear_solver'] = 'newton'
prm['newton_solver']['relaxation_parameter'] = 1.
prm['newton_solver']['relative_tolerance'] = 1e-9
prm['newton_solver']['absolute_tolerance'] = 1e-10
prm['newton_solver']['maximum_iterations'] = 20
prm['newton_solver']['error_on_nonconvergence'] = False
prm['newton_solver']['linear_solver'] = 'mumps'
solver.solve()
# Save solution to file (VTK)
(u, p, T) = upT.split(deepcopy=True)
vtkfile_u << u
vtkfile_p << p
vtkfile_T << T
# POST-PROCESSING
ds_bc = ds(subdomain_data=boundaries)
U = sqrt(dot(u, u))
u_in_avg = assemble(U * ds_bc(association_table["inlet"])) / (We * He)
u_out_avg = assemble(U * ds_bc(association_table["outlet"])) / (We * He)
T_in_avg = assemble(
U * T * ds_bc(association_table["inlet"])) / (u_in_avg * We * He)
T_out_avg = assemble(
U * T * ds_bc(association_table["outlet"])) / (u_out_avg * We * He)
DT_avg = T_out_avg - T_in_avg
Heat_Load = u_in_avg * We * He * rho * cp * DT_avg
print('==============================')
print('u in avg:', u_in_avg)
print('u out avg:', u_out_avg)
print('T in avg:', T_in_avg)
print('T out avg:', T_out_avg)
print('DT avg:', DT_avg)
print('==============================')
Area = assemble(T / T * ds_bc(association_table["noslip"]))
LMDT = ((Tw - T_out_avg) - (Tw - T_in_avg)) / ln(
(Tw - T_out_avg) / (Tw - T_in_avg))
htc_avg = assemble(
dot(k * grad(T), n) * ds_bc(association_table["noslip"])) / Area / LMDT
Nu = htc_avg * Dh / k
print('Heat_Load:', Heat_Load)
print("htc_avg = ", htc_avg)
print("Nu = ", Nu)
htc_avg = Heat_Load / (Area * LMDT)
Nu = htc_avg * Dh / k
print("LMDT = ", LMDT)
print("htc_avg = ", htc_avg)
print("Nu = ", Nu)
return Nu
Flow_Length = 18.46e-3
Dh = 2.8e-3
# Fluid properties
rho = 1.127 # air density at 20 degC, 1 atm, [kg/m3]
nu = 16.92E-6 # air kinematic viscosity at 20 degC, 1 atm, [m2/s]
mu = nu * rho
cp = 1008. # air heat capacity @ 40°C (J/kg K)
k = 27.35e-3 # air thermal conductivity @40°C (W/m/K)
p_0 = 0. # outlet air pressure (atmospheric pressure), normalized
T_0 = 0. # Inlet temperature (K)
u_0 = 5.67 # Inlet velocity (m/s)
qw = 1000. # (W/m2)
# LOAD MESH
mesh, boundaries, association_table = import_mesh_from_xdmf(
prefix="SquareDuct", dim=3)
# Build function space
P2 = VectorElement('Lagrange', mesh.ufl_cell(), 2)
P1 = FiniteElement('Lagrange', mesh.ufl_cell(), 1)
element = MixedElement([P2, P1, P1])
W = FunctionSpace(mesh, element)
(v, q, s) = TestFunctions(W)
upT = Function(W)
# Define initial conditions
e_u0 = Expression(('0.', '0.', 'u0'), u0=Constant(u_0), degree=1)
e_p0 = Expression('0.', degree=1)
e_T0 = Expression('0.', degree=1)
u0 = interpolate(e_u0, W.sub(0).collapse())
p0 = interpolate(e_p0, W.sub(1).collapse())