def FluidNonLinearSetup(Pressure,mu, u_k):
MO.PrintStr("Preconditioning Fluid linear setup",3,"=")
# parameters['linear_algebra_backend'] = 'uBLAS'
p = TrialFunction(Pressure)
q = TestFunction(Pressure)
mesh = Pressure.mesh()
N = FacetNormal(Pressure.mesh())
h = CellSize(Pressure.mesh())
h_avg =avg(h)
alpha = 10.0
gamma =10.0
tic()
if Pressure.__str__().find("CG") == -1:
Fp = assemble(mu*(jump(q)*jump(p)*dx(mesh)) \
+ inner(inner(grad(p),u_k),q)*dx(mesh)- (1./2)*inner(u_k,N)*inner(q,p)*ds(mesh) \
-(1./2)*(inner(u_k('+'),N('+'))+inner(u_k('-'),N('-')))*avg(inner(q,p))*ds(mesh) \
-dot(avg(q),dot(outer(p('+'),N('+'))+outer(p('-'),N('-')),avg(u_k)))*dS(Pressure.mesh()))
else:
if mesh.topology().dim() == 2:
Fp = assemble(mu*inner(grad(q), grad(p))*dx(mesh)+inner((u_k[0]*grad(p)[0]+u_k[1]*grad(p)[1]),q)*dx(mesh) + (1./2)*div(u_k)*inner(p,q)*dx(mesh) + (1./2)*(u_k[0]*N[0]+u_k[1]*N[1])*inner(p,q)*ds(mesh))
else:
Fp = assemble(mu*inner(grad(q), grad(p))*dx(mesh)+inner((u_k[0]*grad(p)[0]+u_k[1]*grad(p)[1]+u_k[2]*grad(p)[2]),q)*dx(mesh) + (1./2)*div(u_k)*inner(p,q)*dx(mesh) - (1./2)*(u_k[0]*N[0]+u_k[1]*N[1]+u_k[2]*N[2])*inner(p,q)*ds(mesh))# + (-mu*inner(grad(q),N)*p + inner(u_k, N)*q*p)*ds(2))
Fp = CP.Assemble(Fp)
print ("{:40}").format("DG convection-diffusion assemble, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
tic()
kspFp= NSprecondSetup.PCDKSPnonlinear(Fp)
print ("{:40}").format("Non-linear fluid precond, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
print "\n\n"
return kspFp, Fp
def FluidLinearSetup(Pressure,mu):
MO.PrintStr("Preconditioning Fluid linear setup",3,"=","\n\n")
parameters['linear_algebra_backend'] = 'uBLAS'
p = TrialFunction(Pressure)
q = TestFunction(Pressure)
N = FacetNormal(Pressure.mesh())
h = CellSize(Pressure.mesh())
h_avg =avg(h)
alpha = 10.0
gamma =10.0
tic()
if Pressure.__str__().find("CG") == -1:
L = assemble(mu*(inner(grad(q), grad(p))*dx(Pressure.mesh()) \
- inner(avg(grad(q)), outer(p('+'),N('+'))+outer(p('-'),N('-')))*dS(Pressure.mesh()) \
- inner(outer(q('+'),N('+'))+outer(q('-'),N('-')), avg(grad(p)))*dS(Pressure.mesh()) \
+ alpha/h_avg*inner(outer(q('+'),N('+'))+outer(q('-'),N('-')),outer(p('+'),N('+'))+outer(p('-'),N('-')))*dS(Pressure.mesh()) \
- inner(outer(q,N), grad(p))*ds(Pressure.mesh()) \
- inner(grad(q), outer(p,N))*ds(Pressure.mesh()) \
+ gamma/h*inner(q,p)*ds(Pressure.mesh())))
else:
L = assemble(mu*(inner(grad(q), grad(p))*dx(Pressure.mesh())))
L = PETSc.Mat().createAIJ(size=L.sparray().shape,csr=(L.sparray().indptr, L.sparray().indices, L.sparray().data))
print ("{:40}").format("DG scalar Laplacian assemble, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
tic()
Q = assemble((1./mu)*inner(p,q)*dx)
Q = PETSc.Mat().createAIJ(size=Q.sparray().shape,csr=(Q.sparray().indptr, Q.sparray().indices, Q.sparray().data))
print ("{:40}").format("DG scalar mass matrix assemble, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
tic()
kspA, ksp = NSprecondSetup.PCDKSPlinear(Q, L)
print ("{:40}").format("Linear fluid precond setup, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
return [kspA,ksp], [L,Q]
def FluidLinearSetup(Pressure, mu, mesh):
MO.PrintStr("Preconditioning Fluid linear setup", 3, "=", "\n\n")
# parameters['linear_algebra_backend'] = 'uBLAS'
q = TrialFunction(Pressure)
p = TestFunction(Pressure)
tic()
L = assemble(mu * inner(grad(q), grad(p)) * dx,
form_compiler_parameters=ffc_options)
L = CP.Assemble(L)
print("{:40}").format("CG scalar Laplacian assemble, time: "), " ==> ", (
"{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(
time.strftime('%X %x %Z')[0:5])
tic()
Q = assemble((1. / mu) * inner(p, q) * dx,
form_compiler_parameters=ffc_options)
Q = CP.Assemble(Q)
print(
"{:40}").format("DG scalar mass matrix assemble, time: "), " ==> ", (
"{:4f}").format(
toc()), ("{:9}").format(" time: "), ("{:4}").format(
time.strftime('%X %x %Z')[0:5])
tic()
kspL, kspQ = NSprecondSetup.PCDKSPlinear(L, Q)
print("{:40}").format("Linear fluid precond setup, time: "), " ==> ", (
"{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(
time.strftime('%X %x %Z')[0:5])
return [kspL, kspQ], [L, Q]
def FluidLinearSetup(Pressure,mu,mesh, boundaries, domains):
MO.PrintStr("Preconditioning Fluid linear setup",3,"=","\n\n")
# parameters['linear_algebra_backend'] = 'uBLAS'
q = TrialFunction(Pressure)
p = TestFunction(Pressure)
dx = Measure('dx', domain=mesh, subdomain_data=domains)
ds = Measure('ds', domain=mesh, subdomain_data=boundaries)
N = FacetNormal(Pressure.mesh())
h = CellSize(Pressure.mesh())
h_avg =avg(h)
alpha = 10.0
gamma =10.0
tic()
if Pressure.__str__().find("CG") == -1:
L = assemble(mu*(jump(q)*jump(p)*dx(Pressure.mesh())))
else:
L = assemble(mu*(inner(grad(q), grad(p))*dx(Pressure.mesh())))# + inner(grad(q),N)*p*ds(2))
L = CP.Assemble(L)
print ("{:40}").format("CG scalar Laplacian assemble, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
tic()
Q = assemble((1./mu)*inner(p,q)*dx)
Q = CP.Assemble(Q)
print ("{:40}").format("DG scalar mass matrix assemble, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
tic()
kspA, ksp = NSprecondSetup.PCDKSPlinear(Q, L)
print ("{:40}").format("Linear fluid precond setup, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
return [kspA,ksp], [L,Q]
def FluidNonLinearSetup(Pressure, mu, u_k):
MO.PrintStr("Preconditioning Fluid linear setup", 3, "=")
parameters['linear_algebra_backend'] = 'uBLAS'
p = TrialFunction(Pressure)
q = TestFunction(Pressure)
mesh = Pressure.mesh()
N = FacetNormal(Pressure.mesh())
h = CellSize(Pressure.mesh())
h_avg = avg(h)
alpha = 10.0
gamma = 10.0
tic()
Fp = assemble(mu*(inner(grad(q), grad(p))*dx(mesh) \
- inner(avg(grad(q)), outer(p('+'),N('+'))+outer(p('-'),N('-')))*dS (Pressure.mesh())\
- inner(outer(q('+'),N('+'))+outer(q('-'),N('-')), avg(grad(p)))*dS (Pressure.mesh())\
+
alpha/h_avg*inner(outer(q('+'),N('+'))+outer(q('-'),N('-')),outer(p('+'),N('+'))+outer(p('-'),N('-')))*dS(Pressure.mesh()) \
- inner(outer(q,N), grad(p))*ds(mesh) \
- inner(grad(q), outer(p,N))*ds(mesh) \
+ gamma/h*inner(q,p)*ds(mesh)) \
+ inner(inner(grad(p),u_k),q)*dx(mesh)- (1/2)*inner(u_k,N)*inner(q,p)*ds(mesh) \
-(1/2)*(inner(u_k('+'),N('+'))+inner(u_k('-'),N('-')))*avg(inner(q,p))*ds(mesh) \
-dot(avg(q),dot(outer(p('+'),N('+'))+outer(p('-'),N('-')),avg(u_k)))*dS(Pressure.mesh()))
Fp = PETSc.Mat().createAIJ(size=Fp.sparray().shape,
csr=(Fp.sparray().indptr, Fp.sparray().indices,
Fp.sparray().data))
print("{:40}"
).format("DG convection-diffusion assemble, time: "), " ==> ", (
"{:4f}").format(
toc()), ("{:9}").format(" time: "), ("{:4}").format(
time.strftime('%X %x %Z')[0:5])
tic()
kspFp = NSprecondSetup.PCDKSPnonlinear(Fp)
print("{:40}").format("Non-linear fluid precond, time: "), " ==> ", (
"{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(
time.strftime('%X %x %Z')[0:5])
print "\n\n"
return kspFp, Fp
def foo():
m = 4
errL2u = np.zeros((m - 1, 1))
errH1u = np.zeros((m - 1, 1))
errL2p = np.zeros((m - 1, 1))
errL2b = np.zeros((m - 1, 1))
errCurlb = np.zeros((m - 1, 1))
errL2r = np.zeros((m - 1, 1))
errH1r = np.zeros((m - 1, 1))
l2uorder = np.zeros((m - 1, 1))
H1uorder = np.zeros((m - 1, 1))
l2porder = np.zeros((m - 1, 1))
l2border = np.zeros((m - 1, 1))
Curlborder = np.zeros((m - 1, 1))
l2rorder = np.zeros((m - 1, 1))
H1rorder = np.zeros((m - 1, 1))
NN = np.zeros((m - 1, 1))
DoF = np.zeros((m - 1, 1))
Velocitydim = np.zeros((m - 1, 1))
Magneticdim = np.zeros((m - 1, 1))
Pressuredim = np.zeros((m - 1, 1))
Lagrangedim = np.zeros((m - 1, 1))
Wdim = np.zeros((m - 1, 1))
iterations = np.zeros((m - 1, 1))
SolTime = np.zeros((m - 1, 1))
udiv = np.zeros((m - 1, 1))
MU = np.zeros((m - 1, 1))
level = np.zeros((m - 1, 1))
NSave = np.zeros((m - 1, 1))
Mave = np.zeros((m - 1, 1))
TotalTime = np.zeros((m - 1, 1))
nn = 2
dim = 2
ShowResultPlots = 'yes'
split = 'Linear'
MU[0] = 1e0
for xx in xrange(1, m):
print xx
level[xx - 1] = xx + 0
nn = 2**(level[xx - 1])
# Create mesh and define function space
nn = int(nn)
NN[xx - 1] = nn / 2
# parameters["form_compiler"]["quadrature_degree"] = 6
# parameters = CP.ParameterSetup()
mesh = UnitSquareMesh(nn, nn)
order = 2
parameters['reorder_dofs_serial'] = False
Velocity = VectorFunctionSpace(mesh, "CG", order)
Pressure = FunctionSpace(mesh, "CG", order - 1)
Magnetic = FunctionSpace(mesh, "N1curl", order - 1)
Lagrange = FunctionSpace(mesh, "CG", order - 1)
W = MixedFunctionSpace([Velocity, Pressure, Magnetic, Lagrange])
# W = Velocity*Pressure*Magnetic*Lagrange
Velocitydim[xx - 1] = Velocity.dim()
Pressuredim[xx - 1] = Pressure.dim()
Magneticdim[xx - 1] = Magnetic.dim()
Lagrangedim[xx - 1] = Lagrange.dim()
Wdim[xx - 1] = W.dim()
print "\n\nW: ", Wdim[xx - 1], "Velocity: ", Velocitydim[
xx -
1], "Pressure: ", Pressuredim[xx - 1], "Magnetic: ", Magneticdim[
xx - 1], "Lagrange: ", Lagrangedim[xx - 1], "\n\n"
dim = [Velocity.dim(), Pressure.dim(), Magnetic.dim(), Lagrange.dim()]
def boundary(x, on_boundary):
return on_boundary
u0, p0, b0, r0, Laplacian, Advection, gradPres, CurlCurl, gradR, NS_Couple, M_Couple = ExactSol.MHD2D(
4, 1, mesh)
bcu = DirichletBC(Velocity, u0, boundary)
bcb = DirichletBC(Magnetic, b0, boundary)
bcr = DirichletBC(Lagrange, r0, boundary)
# bc = [u0,p0,b0,r0]
bcs = [bcu, bcb, bcr]
FSpaces = [Velocity, Pressure, Magnetic, Lagrange]
(u, b, p, r) = TrialFunctions(W)
(v, c, q, s) = TestFunctions(W)
kappa = 10.0
Mu_m = 10.0
MU = 1.0 / 1
IterType = 'Full'
Split = "No"
Saddle = "No"
Stokes = "No"
SetupType = 'python-class'
F_NS = -MU * Laplacian + Advection + gradPres - kappa * NS_Couple
if kappa == 0:
F_M = Mu_m * CurlCurl + gradR - kappa * M_Couple
else:
F_M = Mu_m * kappa * CurlCurl + gradR - kappa * M_Couple
params = [kappa, Mu_m, MU]
MO.PrintStr("Seting up initial guess matricies", 2, "=", "\n\n", "\n")
BCtime = time.time()
BC = MHDsetup.BoundaryIndices(mesh)
MO.StrTimePrint("BC index function, time: ", time.time() - BCtime)
Hiptmairtol = 1e-6
HiptmairMatrices = PrecondSetup.MagneticSetup(Magnetic, Lagrange, b0,
r0, Hiptmairtol, params)
MO.PrintStr("Setting up MHD initial guess", 5, "+", "\n\n", "\n\n")
u_k, p_k, b_k, r_k = common.InitialGuess(FSpaces, [u0, p0, b0, r0],
[F_NS, F_M],
params,
HiptmairMatrices,
1e-10,
Neumann=Expression(
("0", "0")),
options="New")
b_t = TrialFunction(Velocity)
c_t = TestFunction(Velocity)
ones = Function(Pressure)
ones.vector()[:] = (0 * ones.vector().array() + 1)
# pConst = - assemble(p_k*dx)/assemble(ones*dx)
p_k.vector()[:] += -assemble(p_k * dx) / assemble(ones * dx)
x = Iter.u_prev(u_k, p_k, b_k, r_k)
KSPlinearfluids, MatrixLinearFluids = PrecondSetup.FluidLinearSetup(
Pressure, MU)
kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
#plot(b_k)
ns, maxwell, CoupleTerm, Lmaxwell, Lns = forms.MHD2D(
mesh, W, F_M, F_NS, u_k, b_k, params, IterType, "CG", Saddle,
Stokes)
RHSform = forms.PicardRHS(mesh, W, u_k, p_k, b_k, r_k, params, "CG",
Saddle, Stokes)
bcu = DirichletBC(W.sub(0), Expression(("0.0", "0.0")), boundary)
bcb = DirichletBC(W.sub(2), Expression(("0.0", "0.0")), boundary)
bcr = DirichletBC(W.sub(3), Expression(("0.0")), boundary)
bcs = [bcu, bcb, bcr]
parameters['linear_algebra_backend'] = 'uBLAS'
eps = 1.0 # error measure ||u-u_k||
tol = 1.0E-4 # tolerance
iter = 0 # iteration counter
maxiter = 10 # max no of iterations allowed
SolutionTime = 0
outer = 0
# parameters['linear_algebra_backend'] = 'uBLAS'
# FSpaces = [Velocity,Magnetic,Pressure,Lagrange]
if IterType == "CD":
MO.PrintStr("Setting up PETSc " + SetupType, 2, "=", "\n", "\n")
Alin = MHDsetup.Assemble(W, ns, maxwell, CoupleTerm, Lns, Lmaxwell,
RHSform, bcs + BC, "Linear", IterType)
Fnlin, b = MHDsetup.Assemble(W, ns, maxwell, CoupleTerm, Lns,
Lmaxwell, RHSform, bcs + BC,
"NonLinear", IterType)
A = Fnlin + Alin
A, b = MHDsetup.SystemAssemble(FSpaces, A, b, SetupType, IterType)
u = b.duplicate()
u_is = PETSc.IS().createGeneral(range(Velocity.dim()))
NS_is = PETSc.IS().createGeneral(range(Velocity.dim() +
Pressure.dim()))
M_is = PETSc.IS().createGeneral(
range(Velocity.dim() + Pressure.dim(), W.dim()))
OuterTol = 1e-5
InnerTol = 1e-5
NSits = 0
Mits = 0
TotalStart = time.time()
SolutionTime = 0
while eps > tol and iter < maxiter:
iter += 1
MO.PrintStr("Iter " + str(iter), 7, "=", "\n\n", "\n\n")
AssembleTime = time.time()
if IterType == "CD":
MO.StrTimePrint("MHD CD RHS assemble, time: ",
time.time() - AssembleTime)
b = MHDsetup.Assemble(W, ns, maxwell, CoupleTerm, Lns,
Lmaxwell, RHSform, bcs + BC, "CD",
IterType)
else:
MO.PrintStr("Setting up PETSc " + SetupType, 2, "=", "\n",
"\n")
if Split == "Yes":
if iter == 1:
Alin = MHDsetup.Assemble(W, ns, maxwell, CoupleTerm,
Lns, Lmaxwell, RHSform,
bcs + BC, "Linear", IterType)
Fnlin, b = MHDsetup.Assemble(W, ns, maxwell,
CoupleTerm, Lns, Lmaxwell,
RHSform, bcs + BC,
"NonLinear", IterType)
A = Fnlin + Alin
A, b = MHDsetup.SystemAssemble(FSpaces, A, b,
SetupType, IterType)
u = b.duplicate()
else:
Fnline, b = MHDsetup.Assemble(W, ns, maxwell,
CoupleTerm, Lns,
Lmaxwell, RHSform,
bcs + BC, "NonLinear",
IterType)
A = Fnlin + Alin
A, b = MHDsetup.SystemAssemble(FSpaces, A, b,
SetupType, IterType)
else:
AA, bb = assemble_system(maxwell + ns + CoupleTerm,
(Lmaxwell + Lns) - RHSform, bcs)
A, b = CP.Assemble(AA, bb)
# if iter == 1:
MO.StrTimePrint("MHD total assemble, time: ",
time.time() - AssembleTime)
u = b.duplicate()
kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
print "Inititial guess norm: ", u.norm(
PETSc.NormType.NORM_INFINITY)
#A,Q
if IterType == 'Full':
n = FacetNormal(mesh)
mat = as_matrix([[b_k[1] * b_k[1], -b_k[1] * b_k[0]],
[-b_k[1] * b_k[0], b_k[0] * b_k[0]]])
a = params[2] * inner(grad(b_t), grad(c_t)) * dx(
W.mesh()) + inner((grad(b_t) * u_k), c_t) * dx(W.mesh(
)) + (1. / 2) * div(u_k) * inner(c_t, b_t) * dx(
W.mesh()) - (1. / 2) * inner(u_k, n) * inner(
c_t, b_t) * ds(W.mesh()) + kappa / Mu_m * inner(
mat * b_t, c_t) * dx(W.mesh())
ShiftedMass = assemble(a)
bcu.apply(ShiftedMass)
ShiftedMass = CP.Assemble(ShiftedMass)
kspF = NSprecondSetup.LSCKSPnonlinear(ShiftedMass)
else:
F = A.getSubMatrix(u_is, u_is)
kspF = NSprecondSetup.LSCKSPnonlinear(F)
aVec, L_M, L_NS, Bt, CoupleT = forms.MHDmatvec(mesh,
W,
Laplacian,
Laplacian,
u_k,
b_k,
u,
b,
p,
r,
params,
"Full",
"CG",
SaddlePoint="No")
bcu = DirichletBC(Velocity, u0, boundary)
PrecondTmult = {'Bt': Bt, 'Ct': CoupleT, 'BC': bcu}
FS = {
'velocity': Velocity,
'pressure': Pressure,
'magnetic': Magnetic,
'multiplier': Lagrange
}
P = PETSc.Mat().createPython([W.dim(), W.dim()])
P.setType('python')
aa = MHDmulti.PetscMatVec(FS, aVec, bcs, PrecondTmult)
P.setPythonContext(aa)
P.setUp()
stime = time.time()
u, mits, nsits = S.solve(A, P, b, u, params, W, 'Directsss',
IterType, OuterTol, InnerTol,
HiptmairMatrices, Hiptmairtol,
KSPlinearfluids, Fp, kspF)
Soltime = time.time() - stime
MO.StrTimePrint("MHD solve, time: ", Soltime)
Mits += mits
NSits += nsits
SolutionTime += Soltime
u1, p1, b1, r1, eps = Iter.PicardToleranceDecouple(
u, x, FSpaces, dim, "2", iter)
p1.vector()[:] += -assemble(p1 * dx) / assemble(ones * dx)
u_k.assign(u1)
p_k.assign(p1)
b_k.assign(b1)
r_k.assign(r1)
uOld = np.concatenate((u_k.vector().array(), p_k.vector().array(),
b_k.vector().array(), r_k.vector().array()),
axis=0)
x = IO.arrayToVec(uOld)
XX = np.concatenate((u_k.vector().array(), p_k.vector().array(),
b_k.vector().array(), r_k.vector().array()),
axis=0)
SolTime[xx - 1] = SolutionTime / iter
NSave[xx - 1] = (float(NSits) / iter)
Mave[xx - 1] = (float(Mits) / iter)
iterations[xx - 1] = iter
TotalTime[xx - 1] = time.time() - TotalStart
# dim = [Velocity.dim(), Pressure.dim(), Magnetic.dim(),Lagrange.dim()]
# ExactSolution = [u0,p0,b0,r0]
# errL2u[xx-1], errH1u[xx-1], errL2p[xx-1], errL2b[xx-1], errCurlb[xx-1], errL2r[xx-1], errH1r[xx-1] = Iter.Errors(XX,mesh,FSpaces,ExactSolution,order,dim, "DG")
# if xx > 1:
# l2uorder[xx-1] = np.abs(np.log2(errL2u[xx-2]/errL2u[xx-1]))
# H1uorder[xx-1] = np.abs(np.log2(errH1u[xx-2]/errH1u[xx-1]))
# l2porder[xx-1] = np.abs(np.log2(errL2p[xx-2]/errL2p[xx-1]))
# l2border[xx-1] = np.abs(np.log2(errL2b[xx-2]/errL2b[xx-1]))
# Curlborder[xx-1] = np.abs(np.log2(errCurlb[xx-2]/errCurlb[xx-1]))
# l2rorder[xx-1] = np.abs(np.log2(errL2r[xx-2]/errL2r[xx-1]))
# H1rorder[xx-1] = np.abs(np.log2(errH1r[xx-2]/errH1r[xx-1]))
# import pandas as pd
# LatexTitles = ["l","DoFu","Dofp","V-L2","L2-order","V-H1","H1-order","P-L2","PL2-order"]
# LatexValues = np.concatenate((level,Velocitydim,Pressuredim,errL2u,l2uorder,errH1u,H1uorder,errL2p,l2porder), axis=1)
# LatexTable = pd.DataFrame(LatexValues, columns = LatexTitles)
# pd.set_option('precision',3)
# LatexTable = MO.PandasFormat(LatexTable,"V-L2","%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,'V-H1',"%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,"H1-order","%1.2f")
# LatexTable = MO.PandasFormat(LatexTable,'L2-order',"%1.2f")
# LatexTable = MO.PandasFormat(LatexTable,"P-L2","%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,'PL2-order',"%1.2f")
# print LatexTable
# print "\n\n Magnetic convergence"
# MagneticTitles = ["l","B DoF","R DoF","B-L2","L2-order","B-Curl","HCurl-order"]
# MagneticValues = np.concatenate((level,Magneticdim,Lagrangedim,errL2b,l2border,errCurlb,Curlborder),axis=1)
# MagneticTable= pd.DataFrame(MagneticValues, columns = MagneticTitles)
# pd.set_option('precision',3)
# MagneticTable = MO.PandasFormat(MagneticTable,"B-Curl","%2.4e")
# MagneticTable = MO.PandasFormat(MagneticTable,'B-L2',"%2.4e")
# MagneticTable = MO.PandasFormat(MagneticTable,"L2-order","%1.2f")
# MagneticTable = MO.PandasFormat(MagneticTable,'HCurl-order',"%1.2f")
# print MagneticTable
# print "\n\n Lagrange convergence"
# LagrangeTitles = ["l","B DoF","R DoF","R-L2","L2-order","R-H1","H1-order"]
# LagrangeValues = np.concatenate((level,Lagrangedim,Lagrangedim,errL2r,l2rorder,errH1r,H1rorder),axis=1)
# LagrangeTable= pd.DataFrame(LagrangeValues, columns = LagrangeTitles)
# pd.set_option('precision',3)
# LagrangeTable = MO.PandasFormat(LagrangeTable,"R-L2","%2.4e")
# LagrangeTable = MO.PandasFormat(LagrangeTable,'R-H1',"%2.4e")
# LagrangeTable = MO.PandasFormat(LagrangeTable,"L2-order","%1.2f")
# LagrangeTable = MO.PandasFormat(LagrangeTable,'H1-order',"%1.2f")
# print LagrangeTable
import pandas as pd
print "\n\n Iteration table"
if IterType == "Full":
IterTitles = [
"l",
"DoF",
"AV solve Time",
"Total picard time",
"picard iterations",
"Av Outer its",
"Av Inner its",
]
else:
IterTitles = [
"l", "DoF", "AV solve Time", "Total picard time",
"picard iterations", "Av NS iters", "Av M iters"
]
IterValues = np.concatenate(
(level, Wdim, SolTime, TotalTime, iterations, Mave, NSave), axis=1)
IterTable = pd.DataFrame(IterValues, columns=IterTitles)
if IterType == "Full":
IterTable = MO.PandasFormat(IterTable, 'Av Outer its', "%2.1f")
IterTable = MO.PandasFormat(IterTable, 'Av Inner its', "%2.1f")
else:
IterTable = MO.PandasFormat(IterTable, 'Av NS iters', "%2.1f")
IterTable = MO.PandasFormat(IterTable, 'Av M iters', "%2.1f")
print IterTable
print " \n Outer Tol: ", OuterTol, "Inner Tol: ", InnerTol
# tableName = "2d_nu="+str(MU)+"_nu_m="+str(Mu_m)+"_kappa="+str(kappa)+"_l="+str(np.min(level))+"-"+str(np.max(level))+".tex"
# IterTable.to_latex(tableName)
# # # if (ShowResultPlots == 'yes'):
# plot(u_k)
# plot(interpolate(u0,Velocity))
#
# plot(p_k)
#
# plot(interpolate(p0,Pressure))
#
# plot(b_k)
# plot(interpolate(b0,Magnetic))
#
# plot(r_k)
# plot(interpolate(r0,Lagrange))
#
# interactive()
interactive()
# print "Inititial guess norm: ", u.norm(PETSc.NormType.NORM_INFINITY)
# #A,Q
n = FacetNormal(mesh)
b_t = TrialFunction(Velocity)
c_t = TestFunction(Velocity)
mat = as_matrix([[b_k[1] * b_k[1], -b_k[1] * b_k[0]],
[-b_k[1] * b_k[0], b_k[0] * b_k[0]]])
aa = params[2] * inner(grad(b_t), grad(c_t)) * dx(W.mesh()) + inner(
(grad(b_t) * u_k), c_t
) * dx(W.mesh()) + (1. / 2) * div(u_k) * inner(c_t, b_t) * dx(
W.mesh()) - (1. / 2) * inner(u_k, n) * inner(c_t, b_t) * ds(
W.mesh()) + kappa / Mu_m * inner(mat * b_t, c_t) * dx(W.mesh())
ShiftedMass = assemble(aa)
bcu.apply(ShiftedMass)
ShiftedMass = CP.Assemble(ShiftedMass)
kspF = NSprecondSetup.LSCKSPnonlinear(ShiftedMass)
stime = time.time()
u, mits, nsits = S.solve(A, b, u, params, W, 'Direct', IterType,
OuterTol, InnerTol, HiptmairMatrices,
Hiptmairtol, KSPlinearfluids, Fp, kspF)
Soltime = time.time() - stime
MO.StrTimePrint("MHD solve, time: ", Soltime)
Mits += mits
NSits += nsits
SolutionTime += Soltime
u1, p1, b1, r1, eps = Iter.PicardToleranceDecouple(
u, x, FSpaces, dim, "2", iter)
p1.vector()[:] += -assemble(p1 * dx) / assemble(ones * dx)
def foo():
m = 6
errL2u = np.zeros((m - 1, 1))
errH1u = np.zeros((m - 1, 1))
errL2p = np.zeros((m - 1, 1))
errL2b = np.zeros((m - 1, 1))
errCurlb = np.zeros((m - 1, 1))
errL2r = np.zeros((m - 1, 1))
errH1r = np.zeros((m - 1, 1))
l2uorder = np.zeros((m - 1, 1))
H1uorder = np.zeros((m - 1, 1))
l2porder = np.zeros((m - 1, 1))
l2border = np.zeros((m - 1, 1))
Curlborder = np.zeros((m - 1, 1))
l2rorder = np.zeros((m - 1, 1))
H1rorder = np.zeros((m - 1, 1))
NN = np.zeros((m - 1, 1))
DoF = np.zeros((m - 1, 1))
Velocitydim = np.zeros((m - 1, 1))
Magneticdim = np.zeros((m - 1, 1))
Pressuredim = np.zeros((m - 1, 1))
Lagrangedim = np.zeros((m - 1, 1))
Wdim = np.zeros((m - 1, 1))
iterations = np.zeros((m - 1, 1))
SolTime = np.zeros((m - 1, 1))
udiv = np.zeros((m - 1, 1))
MU = np.zeros((m - 1, 1))
level = np.zeros((m - 1, 1))
NSave = np.zeros((m - 1, 1))
Mave = np.zeros((m - 1, 1))
TotalTime = np.zeros((m - 1, 1))
nn = 2
dim = 2
ShowResultPlots = 'yes'
split = 'Linear'
kappa = 0.01
for yy in xrange(1, 5):
kappa = kappa * 10
for xx in xrange(1, m):
print xx
level[xx - 1] = xx + 2
nn = 2**(level[xx - 1])
# Create mesh and define function space
nn = int(nn)
NN[xx - 1] = nn / 2
# parameters["form_compiler"]["quadrature_degree"] = 6
# parameters = CP.ParameterSetup()
mesh = UnitSquareMesh(nn, nn)
order = 1
parameters['reorder_dofs_serial'] = False
Velocity = VectorFunctionSpace(mesh, "CG", order)
Pressure = FunctionSpace(mesh, "DG", order - 1)
Magnetic = FunctionSpace(mesh, "N1curl", order)
Lagrange = FunctionSpace(mesh, "CG", order)
W = MixedFunctionSpace([Velocity, Pressure, Magnetic, Lagrange])
# W = Velocity*Pressure*Magnetic*Lagrange
Velocitydim[xx - 1] = Velocity.dim()
Pressuredim[xx - 1] = Pressure.dim()
Magneticdim[xx - 1] = Magnetic.dim()
Lagrangedim[xx - 1] = Lagrange.dim()
Wdim[xx - 1] = W.dim()
print "\n\nW: ", Wdim[xx - 1], "Velocity: ", Velocitydim[
xx - 1], "Pressure: ", Pressuredim[
xx - 1], "Magnetic: ", Magneticdim[
xx - 1], "Lagrange: ", Lagrangedim[xx - 1], "\n\n"
dim = [
Velocity.dim(),
Pressure.dim(),
Magnetic.dim(),
Lagrange.dim()
]
def boundary(x, on_boundary):
return on_boundary
u0, p0, b0, r0, Laplacian, Advection, gradPres, CurlCurl, gradR, NS_Couple, M_Couple = ExactSol.MHD2D(
4, 1)
bcu = DirichletBC(W.sub(0), u0, boundary)
bcb = DirichletBC(W.sub(2), b0, boundary)
bcr = DirichletBC(W.sub(3), r0, boundary)
# bc = [u0,p0,b0,r0]
bcs = [bcu, bcb, bcr]
FSpaces = [Velocity, Pressure, Magnetic, Lagrange]
(u, b, p, r) = TrialFunctions(W)
(v, c, q, s) = TestFunctions(W)
#kappa = 1.0
MU = 1.0
Mu_m = 1e1
IterType = 'Combined'
F_NS = -MU * Laplacian + Advection + gradPres - kappa * NS_Couple
if kappa == 0:
F_M = Mu_m * CurlCurl + gradR - kappa * M_Couple
else:
F_M = Mu_m * kappa * CurlCurl + gradR - kappa * M_Couple
params = [kappa, Mu_m, MU]
# MO.PrintStr("Preconditioning MHD setup",5,"+","\n\n","\n\n")
Hiptmairtol = 1e-5
HiptmairMatrices = PrecondSetup.MagneticSetup(
Magnetic, Lagrange, b0, r0, Hiptmairtol, params)
MO.PrintStr("Setting up MHD initial guess", 5, "+", "\n\n", "\n\n")
u_k, p_k, b_k, r_k = common.InitialGuess(FSpaces, [u0, p0, b0, r0],
[F_NS, F_M],
params,
HiptmairMatrices,
1e-6,
Neumann=Expression(
("0", "0")),
options="New",
FS="DG")
#plot(p_k, interactive = True)
b_t = TrialFunction(Velocity)
c_t = TestFunction(Velocity)
#print assemble(inner(b,c)*dx).array().shape
#print mat
#ShiftedMass = assemble(inner(mat*b,c)*dx)
#as_vector([inner(b,c)[0]*b_k[0],inner(b,c)[1]*(-b_k[1])])
ones = Function(Pressure)
ones.vector()[:] = (0 * ones.vector().array() + 1)
# pConst = - assemble(p_k*dx)/assemble(ones*dx)
p_k.vector()[:] += -assemble(p_k * dx) / assemble(ones * dx)
x = Iter.u_prev(u_k, p_k, b_k, r_k)
KSPlinearfluids, MatrixLinearFluids = PrecondSetup.FluidLinearSetup(
Pressure, MU)
kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
#plot(b_k)
ns, maxwell, CoupleTerm, Lmaxwell, Lns = forms.MHD2D(
mesh, W, F_M, F_NS, u_k, b_k, params, IterType, "DG")
RHSform = forms.PicardRHS(mesh, W, u_k, p_k, b_k, r_k, params,
"DG")
bcu = DirichletBC(W.sub(0), Expression(("0.0", "0.0")), boundary)
bcb = DirichletBC(W.sub(2), Expression(("0.0", "0.0")), boundary)
bcr = DirichletBC(W.sub(3), Expression(("0.0")), boundary)
bcs = [bcu, bcb, bcr]
eps = 1.0 # error measure ||u-u_k||
tol = 1.0E-4 # tolerance
iter = 0 # iteration counter
maxiter = 40 # max no of iterations allowed
SolutionTime = 0
outer = 0
# parameters['linear_algebra_backend'] = 'uBLAS'
# FSpaces = [Velocity,Magnetic,Pressure,Lagrange]
if IterType == "CD":
AA, bb = assemble_system(maxwell + ns,
(Lmaxwell + Lns) - RHSform, bcs)
A, b = CP.Assemble(AA, bb)
# u = b.duplicate()
# P = CP.Assemble(PP)
u_is = PETSc.IS().createGeneral(range(Velocity.dim()))
NS_is = PETSc.IS().createGeneral(
range(Velocity.dim() + Pressure.dim()))
M_is = PETSc.IS().createGeneral(
range(Velocity.dim() + Pressure.dim(), W.dim()))
OuterTol = 1e-5
InnerTol = 1e-5
NSits = 0
Mits = 0
TotalStart = time.time()
SolutionTime = 0
while eps > tol and iter < maxiter:
iter += 1
MO.PrintStr("Iter " + str(iter), 7, "=", "\n\n", "\n\n")
tic()
if IterType == "CD":
bb = assemble((Lmaxwell + Lns) - RHSform)
for bc in bcs:
bc.apply(bb)
FF = AA.sparray()[0:dim[0], 0:dim[0]]
A, b = CP.Assemble(AA, bb)
# if iter == 1
if iter == 1:
u = b.duplicate()
F = A.getSubMatrix(u_is, u_is)
kspF = NSprecondSetup.LSCKSPnonlinear(F)
else:
AA, bb = assemble_system(maxwell + ns + CoupleTerm,
(Lmaxwell + Lns) - RHSform, bcs)
A, b = CP.Assemble(AA, bb)
# if iter == 1:
if iter == 1:
u = b.duplicate()
print("{:40}").format("MHD assemble, time: "), " ==> ", (
"{:4f}").format(
toc()), ("{:9}").format(" time: "), ("{:4}").format(
time.strftime('%X %x %Z')[0:5])
kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
print "Inititial guess norm: ", u.norm()
#A,Q
if IterType == 'Combined':
n = FacetNormal(mesh)
mat = as_matrix([[b_k[1] * b_k[1], -b_k[1] * b_k[0]],
[-b_k[1] * b_k[0], b_k[0] * b_k[0]]])
F = A.getSubMatrix(u_is, u_is)
a = params[2] * inner(grad(b_t), grad(c_t)) * dx(
W.mesh()) + inner((grad(b_t) * u_k), c_t) * dx(
W.mesh()) + (1 / 2) * div(u_k) * inner(
c_t, b_t) * dx(W.mesh()) - (1 / 2) * inner(
u_k, n) * inner(c_t, b_t) * ds(
W.mesh()) + kappa / Mu_m * inner(
mat * b_t, c_t) * dx(W.mesh())
ShiftedMass = assemble(a)
bcu.apply(ShiftedMass)
kspF = NSprecondSetup.LSCKSPnonlinear(F)
else:
F = A.getSubMatrix(u_is, u_is)
kspF = NSprecondSetup.LSCKSPnonlinear(F)
stime = time.time()
u, mits, nsits = S.solve(A, b, u, params, W, IterType,
OuterTol, InnerTol, HiptmairMatrices,
Hiptmairtol, KSPlinearfluids, Fp,
kspF)
Soltime = time.time() - stime
Mits += mits
NSits += nsits
SolutionTime += Soltime
u1, p1, b1, r1, eps = Iter.PicardToleranceDecouple(
u, x, FSpaces, dim, "2", iter)
p1.vector()[:] += -assemble(p1 * dx) / assemble(ones * dx)
u_k.assign(u1)
p_k.assign(p1)
b_k.assign(b1)
r_k.assign(r1)
uOld = np.concatenate(
(u_k.vector().array(), p_k.vector().array(),
b_k.vector().array(), r_k.vector().array()),
axis=0)
x = IO.arrayToVec(uOld)
XX = np.concatenate((u_k.vector().array(), p_k.vector().array(),
b_k.vector().array(), r_k.vector().array()),
axis=0)
SolTime[xx - 1] = SolutionTime / iter
NSave[xx - 1] = (float(NSits) / iter)
Mave[xx - 1] = (float(Mits) / iter)
iterations[xx - 1] = iter
TotalTime[xx - 1] = time.time() - TotalStart
dim = [
Velocity.dim(),
Pressure.dim(),
Magnetic.dim(),
Lagrange.dim()
]
#
# ExactSolution = [u0,p0,b0,r0]
# errL2u[xx-1], errH1u[xx-1], errL2p[xx-1], errL2b[xx-1], errCurlb[xx-1], errL2r[xx-1], errH1r[xx-1] = Iter.Errors(XX,mesh,FSpaces,ExactSolution,order,dim, "DG")
#
# if xx > 1:
# l2uorder[xx-1] = np.abs(np.log2(errL2u[xx-2]/errL2u[xx-1]))
# H1uorder[xx-1] = np.abs(np.log2(errH1u[xx-2]/errH1u[xx-1]))
#
# l2porder[xx-1] = np.abs(np.log2(errL2p[xx-2]/errL2p[xx-1]))
#
# l2border[xx-1] = np.abs(np.log2(errL2b[xx-2]/errL2b[xx-1]))
# Curlborder[xx-1] = np.abs(np.log2(errCurlb[xx-2]/errCurlb[xx-1]))
#
# l2rorder[xx-1] = np.abs(np.log2(errL2r[xx-2]/errL2r[xx-1]))
# H1rorder[xx-1] = np.abs(np.log2(errH1r[xx-2]/errH1r[xx-1]))
import pandas as pd
# LatexTitles = ["l","DoFu","Dofp","V-L2","L2-order","V-H1","H1-order","P-L2","PL2-order"]
# LatexValues = np.concatenate((level,Velocitydim,Pressuredim,errL2u,l2uorder,errH1u,H1uorder,errL2p,l2porder), axis=1)
# LatexTable = pd.DataFrame(LatexValues, columns = LatexTitles)
# pd.set_option('precision',3)
# LatexTable = MO.PandasFormat(LatexTable,"V-L2","%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,'V-H1',"%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,"H1-order","%1.2f")
# LatexTable = MO.PandasFormat(LatexTable,'L2-order',"%1.2f")
# LatexTable = MO.PandasFormat(LatexTable,"P-L2","%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,'PL2-order',"%1.2f")
# print LatexTable
#
#
# print "\n\n Magnetic convergence"
# MagneticTitles = ["l","B DoF","R DoF","B-L2","L2-order","B-Curl","HCurl-order"]
# MagneticValues = np.concatenate((level,Magneticdim,Lagrangedim,errL2b,l2border,errCurlb,Curlborder),axis=1)
# MagneticTable= pd.DataFrame(MagneticValues, columns = MagneticTitles)
# pd.set_option('precision',3)
# MagneticTable = MO.PandasFormat(MagneticTable,"B-Curl","%2.4e")
# MagneticTable = MO.PandasFormat(MagneticTable,'B-L2',"%2.4e")
# MagneticTable = MO.PandasFormat(MagneticTable,"L2-order","%1.2f")
# MagneticTable = MO.PandasFormat(MagneticTable,'HCurl-order',"%1.2f")
# print MagneticTable
#
#
#
#
# import pandas as pd
#
print "\n\n Iteration table"
if IterType == "Full":
IterTitles = [
"l",
"DoF",
"AV solve Time",
"Total picard time",
"picard iterations",
"Av Outer its",
"Av Inner its",
]
else:
IterTitles = [
"l", "DoF", "AV solve Time", "Total picard time",
"picard iterations", "Av NS iters", "Av M iters"
]
IterValues = np.concatenate(
(level, Wdim, SolTime, TotalTime, iterations, Mave, NSave), axis=1)
IterTable = pd.DataFrame(IterValues, columns=IterTitles)
if IterType == "Full":
IterTable = MO.PandasFormat(IterTable, 'Av Outer its', "%2.1f")
IterTable = MO.PandasFormat(IterTable, 'Av Inner its', "%2.1f")
else:
IterTable = MO.PandasFormat(IterTable, 'Av NS iters', "%2.1f")
IterTable = MO.PandasFormat(IterTable, 'Av M iters', "%2.1f")
print IterTable
print " \n Outer Tol: ", OuterTol, "Inner Tol: ", InnerTol
IterTable.to_latex('Tables/IterType=' + IterType + '_n=' + str(m) +
'_mu=' + str(MU) + '_kappa=' + str(kappa) +
'_mu_m=' + str(Mu_m) + '.tex')
# # # if (ShowResultPlots == 'yes'):
# plot(u_k)
# plot(interpolate(u0,Velocity))
#
# plot(p_k)
#
# plot(interpolate(p0,Pressure))
#
# plot(b_k)
# plot(interpolate(b0,Magnetic))
#
# plot(r_k)
# plot(interpolate(r0,Lagrange))
#
# interactive()
interactive()
def foo():
m = 2
errL2u =np.zeros((m-1,1))
errH1u =np.zeros((m-1,1))
errL2p =np.zeros((m-1,1))
errL2b =np.zeros((m-1,1))
errCurlb =np.zeros((m-1,1))
errL2r =np.zeros((m-1,1))
errH1r =np.zeros((m-1,1))
l2uorder = np.zeros((m-1,1))
H1uorder =np.zeros((m-1,1))
l2porder = np.zeros((m-1,1))
l2border = np.zeros((m-1,1))
Curlborder =np.zeros((m-1,1))
l2rorder = np.zeros((m-1,1))
H1rorder = np.zeros((m-1,1))
NN = np.zeros((m-1,1))
DoF = np.zeros((m-1,1))
Velocitydim = np.zeros((m-1,1))
Magneticdim = np.zeros((m-1,1))
Pressuredim = np.zeros((m-1,1))
Lagrangedim = np.zeros((m-1,1))
Wdim = np.zeros((m-1,1))
iterations = np.zeros((m-1,1))
SolTime = np.zeros((m-1,1))
udiv = np.zeros((m-1,1))
MU = np.zeros((m-1,1))
level = np.zeros((m-1,1))
NSave = np.zeros((m-1,1))
Mave = np.zeros((m-1,1))
TotalTime = np.zeros((m-1,1))
nn = 2
dim = 2
ShowResultPlots = 'yes'
split = 'Linear'
MU[0]= 1e0
for xx in xrange(1,m):
print xx
level[xx-1] = xx+ 10
nn = 2**(level[xx-1])
# Create mesh and define function space
nn = int(nn)
NN[xx-1] = nn/2
# parameters["form_compiler"]["quadrature_degree"] = 6
# parameters = CP.ParameterSetup()
mesh = UnitSquareMesh(nn,nn)
order = 1
parameters['reorder_dofs_serial'] = False
Velocity = VectorFunctionSpace(mesh, "CG", order)
Pressure = FunctionSpace(mesh, "DG", order-1)
Magnetic = FunctionSpace(mesh, "N1curl", order)
Lagrange = FunctionSpace(mesh, "CG", order)
W = MixedFunctionSpace([Velocity,Magnetic, Pressure, Lagrange])
# W = Velocity*Pressure*Magnetic*Lagrange
Velocitydim[xx-1] = Velocity.dim()
Pressuredim[xx-1] = Pressure.dim()
Magneticdim[xx-1] = Magnetic.dim()
Lagrangedim[xx-1] = Lagrange.dim()
Wdim[xx-1] = W.dim()
print "\n\nW: ",Wdim[xx-1],"Velocity: ",Velocitydim[xx-1],"Pressure: ",Pressuredim[xx-1],"Magnetic: ",Magneticdim[xx-1],"Lagrange: ",Lagrangedim[xx-1],"\n\n"
dim = [Velocity.dim(), Magnetic.dim(), Pressure.dim(), Lagrange.dim()]
def boundary(x, on_boundary):
return on_boundary
u0, p0,b0, r0, Laplacian, Advection, gradPres,CurlCurl, gradR, NS_Couple, M_Couple = ExactSol.MHD2D(4,1)
bcu = DirichletBC(W.sub(0),u0, boundary)
bcb = DirichletBC(W.sub(1),b0, boundary)
bcr = DirichletBC(W.sub(3),r0, boundary)
# bc = [u0,p0,b0,r0]
bcs = [bcu,bcb,bcr]
FSpaces = [Velocity,Pressure,Magnetic,Lagrange]
(u, b, p, r) = TrialFunctions(W)
(v, c, q, s) = TestFunctions(W)
kappa = 1.0
Mu_m =1e1
MU = 1.0/1
IterType = 'Full'
F_NS = -MU*Laplacian+Advection+gradPres-kappa*NS_Couple
if kappa == 0:
F_M = Mu_m*CurlCurl+gradR -kappa*M_Couple
else:
F_M = Mu_m*kappa*CurlCurl+gradR -kappa*M_Couple
params = [kappa,Mu_m,MU]
# MO.PrintStr("Preconditioning MHD setup",5,"+","\n\n","\n\n")
HiptmairMatrices = PrecondSetup.MagneticSetup(Magnetic, Lagrange, b0, r0, 1e-5, params)
MO.PrintStr("Setting up MHD initial guess",5,"+","\n\n","\n\n")
u_k,p_k,b_k,r_k = common.InitialGuess(FSpaces,[u0,p0,b0,r0],[F_NS,F_M],params,HiptmairMatrices,1e-6,Neumann=Expression(("0","0")),options ="New", FS = "DG")
#plot(p_k, interactive = True)
b_t = TrialFunction(Velocity)
c_t = TestFunction(Velocity)
#print assemble(inner(b,c)*dx).array().shape
#print mat
#ShiftedMass = assemble(inner(mat*b,c)*dx)
#as_vector([inner(b,c)[0]*b_k[0],inner(b,c)[1]*(-b_k[1])])
ones = Function(Pressure)
ones.vector()[:]=(0*ones.vector().array()+1)
# pConst = - assemble(p_k*dx)/assemble(ones*dx)
p_k.vector()[:] += - assemble(p_k*dx)/assemble(ones*dx)
x = Iter.u_prev(u_k,b_k,p_k,r_k)
KSPlinearfluids, MatrixLinearFluids = PrecondSetup.FluidLinearSetup(Pressure, MU)
kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
#plot(b_k)
ns,maxwell,CoupleTerm,Lmaxwell,Lns = forms.MHD2D(mesh, W,F_M,F_NS, u_k,b_k,params,IterType,"DG", SaddlePoint = "Yes")
RHSform = forms.PicardRHS(mesh, W, u_k, p_k, b_k, r_k, params,"DG",SaddlePoint = "Yes")
bcu = DirichletBC(W.sub(0),Expression(("0.0","0.0")), boundary)
bcb = DirichletBC(W.sub(1),Expression(("0.0","0.0")), boundary)
bcr = DirichletBC(W.sub(3),Expression(("0.0")), boundary)
bcs = [bcu,bcb,bcr]
eps = 1.0 # error measure ||u-u_k||
tol = 1.0E-4 # tolerance
iter = 0 # iteration counter
maxiter = 40 # max no of iterations allowed
SolutionTime = 0
outer = 0
# parameters['linear_algebra_backend'] = 'uBLAS'
# FSpaces = [Velocity,Magnetic,Pressure,Lagrange]
if IterType == "CD":
AA, bb = assemble_system(maxwell+ns, (Lmaxwell + Lns) - RHSform, bcs)
A,b = CP.Assemble(AA,bb)
# u = b.duplicate()
# P = CP.Assemble(PP)
u_is = PETSc.IS().createGeneral(range(Velocity.dim()))
NS_is = PETSc.IS().createGeneral(range(Velocity.dim()+Pressure.dim()))
M_is = PETSc.IS().createGeneral(range(Velocity.dim()+Pressure.dim(),W.dim()))
OuterTol = 1e-5
InnerTol = 1e-3
NSits =0
Mits =0
TotalStart =time.time()
SolutionTime = 0
while eps > tol and iter < maxiter:
iter += 1
MO.PrintStr("Iter "+str(iter),7,"=","\n\n","\n\n")
tic()
if IterType == "CD":
bb = assemble((Lmaxwell + Lns) - RHSform)
for bc in bcs:
bc.apply(bb)
FF = AA.sparray()[0:dim[0],0:dim[0]]
A,b = CP.Assemble(AA,bb)
# if iter == 1
if iter == 1:
u = b.duplicate()
F = A.getSubMatrix(u_is,u_is)
kspF = NSprecondSetup.LSCKSPnonlinear(F)
else:
AA, bb = assemble_system(maxwell+ns+CoupleTerm, (Lmaxwell + Lns) - RHSform, bcs)
A,b = CP.Assemble(AA,bb)
del AA, bb
n = FacetNormal(mesh)
mat = as_matrix([[b_k[1]*b_k[1],-b_k[1]*b_k[0]],[-b_k[1]*b_k[0],b_k[0]*b_k[0]]])
F = A.getSubMatrix(u_is,u_is)
a = params[2]*inner(grad(b_t), grad(c_t))*dx(W.mesh()) + inner((grad(b_t)*u_k),c_t)*dx(W.mesh()) +(1/2)*div(u_k)*inner(c_t,b_t)*dx(W.mesh()) - (1/2)*inner(u_k,n)*inner(c_t,b_t)*ds(W.mesh())+kappa/Mu_m*inner(mat*b_t,c_t)*dx(W.mesh())
ShiftedMass = assemble(a)
bcu.apply(ShiftedMass)
#MO.StoreMatrix(AA.sparray()[0:dim[0],0:dim[0]]+ShiftedMass.sparray(),"A")
kspF = NSprecondSetup.LSCKSPnonlinear(F)
# if iter == 1:
if iter == 1:
u = b.duplicate()
print ("{:40}").format("MHD assemble, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
print "Inititial guess norm: ", u.norm()
solver = 'Schur'
if solver == 'Schur':
FF = CP.Assemble(ShiftedMass)
kspF = NSprecondSetup.LSCKSPnonlinear(FF)
ksp = PETSc.KSP()
ksp.create(comm=PETSc.COMM_WORLD)
pc = ksp.getPC()
ksp.setType('fgmres')
pc.setType('python')
pc.setType(PETSc.PC.Type.PYTHON)
# FSpace = [Velocity,Magnetic,Pressure,Lagrange]
reshist = {}
def monitor(ksp, its, fgnorm):
reshist[its] = fgnorm
print its," OUTER:", fgnorm
# ksp.setMonitor(monitor)
ksp.max_it = 1000
FFSS = [Velocity,Magnetic,Pressure,Lagrange]
pc.setPythonContext(MHDpreconditioner.InnerOuterMAGNETICapprox(FFSS,kspF, KSPlinearfluids[0], KSPlinearfluids[1],Fp, HiptmairMatrices[3], HiptmairMatrices[4], HiptmairMatrices[2], HiptmairMatrices[0], HiptmairMatrices[1], HiptmairMatrices[6],1e-5,FF))
#OptDB = PETSc.Options()
# OptDB['pc_factor_mat_solver_package'] = "mumps"
# OptDB['pc_factor_mat_ordering_type'] = "rcm"
# ksp.setFromOptions()
scale = b.norm()
b = b/scale
ksp.setOperators(A,A)
del A
stime = time.time()
ksp.solve(b,u)
Soltime = time.time()- stime
NSits += ksp.its
Mits += ksp.its
# Mits +=dodim
u = u*scale
SolutionTime = SolutionTime +Soltime
MO.PrintStr("Number iterations ="+str(ksp.its),60,"+","\n\n","\n\n")
MO.PrintStr("Time: "+str(Soltime),60,"+","\n\n","\n\n")
else:
kspOuter = PETSc.KSP()
kspOuter.create(comm=PETSc.COMM_WORLD)
FFSS = [Velocity,Magnetic,Pressure,Lagrange]
kspOuter.setType('fgmres')
kspOuter.setOperators(A,A)
pcOuter = kspOuter.getPC()
pcOuter.setType(PETSc.PC.Type.KSP)
kspInner = pcOuter.getKSP()
kspInner.setType('gmres')
pcInner = kspInner.getPC()
# FSpace = [Velocity,Magnetic,Pressure,Lagrange]
reshist = {}
def monitor(ksp, its, fgnorm):
reshist[its] = fgnorm
print its," OUTER:", fgnorm
kspOuter.setMonitor(monitor)
kspOuter.max_it = 500
kspInner.max_it = 100
kspOuter.setTolerances(OuterTol)
kspInner.setTolerances(InnerTol)
pcInner.setType('python')
pcInner.setPythonContext(MHDpreconditioner.InnerOuter(A,FFSS,kspF, KSPlinearfluids[0], KSPlinearfluids[1],Fp, HiptmairMatrices[3], HiptmairMatrices[4], HiptmairMatrices[2], HiptmairMatrices[0], HiptmairMatrices[1], HiptmairMatrices[6],1e-4,F))
# OptDB = PETSc.Options()
PP = PETSc.Mat().create()
PP.setSizes([A.size[0], A.size[0]])
#PP = PETSc.Mat().createPython([A.size[0], A.size[0]])
PP.setType('python')
pp = MHDmulti.P(FFSS,A,MatrixLinearFluids[1],MatrixLinearFluids[0],kspFp,HiptmairMatrices[6])
PP.setPythonContext(pp)
PP.setUp()
kspInner.setOperators(PP,PP)
kspInner.setFromOptions()
scale = b.norm()
b = b/scale
del A
stime = time.time()
kspOuter.solve(b,u)
Soltime = time.time()- stime
NSits += kspOuter.its
Mits += kspInner.its
u = u*scale
SolutionTime = SolutionTime +Soltime
MO.PrintStr("Number of outer iterations ="+str(kspOuter.its),60,"+","\n\n","\n\n")
MO.PrintStr("Number of inner iterations ="+str(kspInner.its),60,"+","\n\n","\n\n")
u1, p1, b1, r1, eps= Iter.PicardToleranceDecouple(u,x,FSpaces,dim,"2",iter, SaddlePoint = "Yes")
p1.vector()[:] += - assemble(p1*dx)/assemble(ones*dx)
u_k.assign(u1)
p_k.assign(p1)
b_k.assign(b1)
r_k.assign(r1)
uOld= np.concatenate((u_k.vector().array(),b_k.vector().array(),p_k.vector().array(),r_k.vector().array()), axis=0)
x = IO.arrayToVec(uOld)
XX= np.concatenate((u_k.vector().array(),p_k.vector().array(),b_k.vector().array(),r_k.vector().array()), axis=0)
SolTime[xx-1] = SolutionTime/iter
NSave[xx-1] = (float(NSits)/iter)
Mave[xx-1] = (float(Mits)/iter)
iterations[xx-1] = iter
TotalTime[xx-1] = time.time() - TotalStart
dim = [Velocity.dim(), Pressure.dim(), Magnetic.dim(),Lagrange.dim()]
#
# ExactSolution = [u0,p0,b0,r0]
# errL2u[xx-1], errH1u[xx-1], errL2p[xx-1], errL2b[xx-1], errCurlb[xx-1], errL2r[xx-1], errH1r[xx-1] = Iter.Errors(XX,mesh,FSpaces,ExactSolution,order,dim, "DG")
#
# if xx > 1:
# l2uorder[xx-1] = np.abs(np.log2(errL2u[xx-2]/errL2u[xx-1]))
# H1uorder[xx-1] = np.abs(np.log2(errH1u[xx-2]/errH1u[xx-1]))
#
# l2porder[xx-1] = np.abs(np.log2(errL2p[xx-2]/errL2p[xx-1]))
#
# l2border[xx-1] = np.abs(np.log2(errL2b[xx-2]/errL2b[xx-1]))
# Curlborder[xx-1] = np.abs(np.log2(errCurlb[xx-2]/errCurlb[xx-1]))
#
# l2rorder[xx-1] = np.abs(np.log2(errL2r[xx-2]/errL2r[xx-1]))
# H1rorder[xx-1] = np.abs(np.log2(errH1r[xx-2]/errH1r[xx-1]))
import pandas as pd
# LatexTitles = ["l","DoFu","Dofp","V-L2","L2-order","V-H1","H1-order","P-L2","PL2-order"]
# LatexValues = np.concatenate((level,Velocitydim,Pressuredim,errL2u,l2uorder,errH1u,H1uorder,errL2p,l2porder), axis=1)
# LatexTable = pd.DataFrame(LatexValues, columns = LatexTitles)
# pd.set_option('precision',3)
# LatexTable = MO.PandasFormat(LatexTable,"V-L2","%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,'V-H1',"%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,"H1-order","%1.2f")
# LatexTable = MO.PandasFormat(LatexTable,'L2-order',"%1.2f")
# LatexTable = MO.PandasFormat(LatexTable,"P-L2","%2.4e")
# LatexTable = MO.PandasFormat(LatexTable,'PL2-order',"%1.2f")
# print LatexTable
#
#
# print "\n\n Magnetic convergence"
# MagneticTitles = ["l","B DoF","R DoF","B-L2","L2-order","B-Curl","HCurl-order"]
# MagneticValues = np.concatenate((level,Magneticdim,Lagrangedim,errL2b,l2border,errCurlb,Curlborder),axis=1)
# MagneticTable= pd.DataFrame(MagneticValues, columns = MagneticTitles)
# pd.set_option('precision',3)
# MagneticTable = MO.PandasFormat(MagneticTable,"B-Curl","%2.4e")
# MagneticTable = MO.PandasFormat(MagneticTable,'B-L2',"%2.4e")
# MagneticTable = MO.PandasFormat(MagneticTable,"L2-order","%1.2f")
# MagneticTable = MO.PandasFormat(MagneticTable,'HCurl-order',"%1.2f")
# print MagneticTable
#
#
#
#
# import pandas as pd
#
print "\n\n Iteration table"
if IterType == "Full":
IterTitles = ["l","DoF","AV solve Time","Total picard time","picard iterations","Av Outer its","Av Inner its",]
else:
IterTitles = ["l","DoF","AV solve Time","Total picard time","picard iterations","Av NS iters","Av M iters"]
IterValues = np.concatenate((level,Wdim,SolTime,TotalTime,iterations,NSave,Mave),axis=1)
IterTable= pd.DataFrame(IterValues, columns = IterTitles)
if IterType == "Full":
IterTable = MO.PandasFormat(IterTable,'Av Outer its',"%2.1f")
IterTable = MO.PandasFormat(IterTable,'Av Inner its',"%2.1f")
else:
IterTable = MO.PandasFormat(IterTable,'Av NS iters',"%2.1f")
IterTable = MO.PandasFormat(IterTable,'Av M iters',"%2.1f")
print IterTable.to_latex()
print " \n Outer Tol: ",OuterTol, "Inner Tol: ", InnerTol
# # # if (ShowResultPlots == 'yes'):
# plot(u_k)
# plot(interpolate(u0,Velocity))
#
# plot(p_k)
#
# plot(interpolate(p0,Pressure))
#
# plot(b_k)
# plot(interpolate(b0,Magnetic))
#
# plot(r_k)
# plot(interpolate(r0,Lagrange))
#
# interactive()
interactive()
TotalStart =time.time()
SolutionTime = 0
while eps > tol and iter < maxiter:
iter += 1
MO.PrintStr("Iter "+str(iter),7,"=","\n\n","\n\n")
tic()
if IterType == "CD":
bb = assemble((Lmaxwell + Lns) - RHSform)
for bc in bcs:
bc.apply(bb)
A,b = CP.Assemble(AA,bb)
# if iter == 1
if iter == 1:
u = b.duplicate()
F = A.getSubMatrix(u_is,u_is)
kspF = NSprecondSetup.LSCKSPnonlinear(F)
else:
AA, bb = assemble_system(maxwell+ns+CoupleTerm, (Lmaxwell + Lns) - RHSform, bcs)
A,b = CP.Assemble(AA,bb)
F = A.getSubMatrix(u_is,u_is)
kspF = NSprecondSetup.LSCKSPnonlinear(F)
# if iter == 1:
if iter == 1:
u = b.duplicate()
print ("{:40}").format("MHD assemble, time: "), " ==> ",("{:4f}").format(toc()), ("{:9}").format(" time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
print "Inititial guess norm: ", u.norm()
stime = time.time()
# ksp.solve(b, u)
Bt = PP[0:V.dim(), V.dim():W.dim()]
d = spdiags(1.0 / Xdiag, 0, len(Xdiag), len(Xdiag))
dBt = (d * Bt).tocsr()
plt.spy(dBt)
plt.show()
BQB = Bt.transpose() * dBt
dBt = PETSc.Mat().createAIJ(size=dBt.shape,
csr=(dBt.indptr, dBt.indices, dBt.data))
print dBt.size
BQB = PETSc.Mat().createAIJ(size=BQB.tocsr().shape,
csr=(BQB.tocsr().indptr,
BQB.tocsr().indices,
BQB.tocsr().data))
# parameters['linear_algebra_backend'] = 'PETSc'
kspBQB = NSprecondSetup.Ksp(BQB)
elif Solver == "PCD":
N = FacetNormal(mesh)
h = CellSize(mesh)
h_avg = avg(h)
alpha = 10.0
gamma = 10.0
(pQ) = TrialFunction(Q)
(qQ) = TestFunction(Q)
print MU
Mass = assemble(inner(pQ, qQ) * dx)
L = MU * (inner(grad(qQ), grad(pQ)) * dx(mesh))
# O = - dot(u_k, n)*pQ('+')*qQ*ds(mesh) - dot(u_k, n)*(pQ('+') - pQ('-'))*qQ('-')*dS(mesh)
pp = Function(Q)
Bt = PP[0:V.dim(),V.dim():W.dim()]
d = spdiags(1.0/Xdiag, 0, len(Xdiag), len(Xdiag))
dBt = (d*Bt).tocsr()
print Bt.transpose()*dBt.todense()
plt.spy(dBt)
plt.show()
BQB = Bt.transpose()*dBt
dBt = PETSc.Mat().createAIJ(size=dBt.shape,csr=(dBt.indptr, dBt.indices, dBt.data))
print dBt.size
BQB = PETSc.Mat().createAIJ(size=BQB.tocsr().shape,csr=(BQB.tocsr().indptr, BQB.tocsr().indices, BQB.tocsr().data))
# parameters['linear_algebra_backend'] = 'PETSc'
kspBQB = NSprecondSetup.LSCKSPlinear(BQB)
elif Solver == "PCD":
N = FacetNormal(mesh)
h = CellSize(mesh)
h_avg =avg(h)
alpha = 10.0
gamma =10.0
(pQ) = TrialFunction(Q)
(qQ) = TestFunction(Q)
print MU
Mass = assemble(inner(pQ,qQ)*dx)
L = MU*(inner(grad(qQ), grad(pQ))*dx(mesh))
# O = - dot(u_k, n)*pQ('+')*qQ*ds(mesh) - dot(u_k, n)*(pQ('+') - pQ('-'))*qQ('-')*dS(mesh)
pp = Function(Q)
Mass = assemble(inner(u,v)*dx)
B = assemble(-div(v)*p*dx)
bc = DirichletBC(V,Expression(("0.0","0.0")), boundary)
#bc.apply(Mass)
Mass = Mass.sparray()
MassD = Mass.diagonal()
del Mass
B = B.sparray()
d = spdiags(1.0/MassD, 0, len(MassD), len(MassD))
QB = d*B
L = B.transpose()*QB
L = PETSc.Mat().createAIJ(size=L.shape,csr=(L.indptr, L.indices, L.data))
QB = PETSc.Mat().createAIJ(size=QB.shape,csr=(QB.indptr, QB.indices, QB.data))
KspL = NSsetup.Ksp(L)
elif Solver == "PCD":
(pQ) = TrialFunction(Q)
(qQ) = TestFunction(Q)
print MU
Mass = assemble(inner(pQ,qQ)*dx)
L = assemble(inner(grad(pQ),grad(qQ))*dx)
fp = MU*inner(grad(qQ), grad(pQ))*dx+inner((u_k[0]*grad(pQ)[0]+u_k[1]*grad(pQ)[1]),qQ)*dx + (1./2)*div(u_k)*inner(pQ,qQ)*dx - (1./2)*(u_k[0]*n[0]+u_k[1]*n[1])*inner(pQ,qQ)*ds
L = CP.Assemble(L)
Mass = CP.Assemble(Mass)
# print L
SolutionTime = 0
while eps > tol and iter < maxiter:
iter += 1
