def eigensORIG(A, AA, W, PCD, L):
IS = IndexSet(W)
F = A.getSubMatrix(IS[0], IS[0])
Ct = A.getSubMatrix(IS[0], IS[1])
Dt = A.getSubMatrix(IS[1], IS[3])
M = A.getSubMatrix(IS[1], IS[1])
Bt = A.getSubMatrix(IS[0], IS[2])
C = A.getSubMatrix(IS[2], IS[2])
F = CP.PETSc2Scipy(F)
Ct = CP.PETSc2Scipy(Ct)
Dt = CP.PETSc2Scipy(Dt)
Bt = CP.PETSc2Scipy(Bt)
L = CP.PETSc2Scipy(L)
M = CP.PETSc2Scipy(M)
Ap = CP.PETSc2Scipy(PCD[0])
Mp = CP.PETSc2Scipy(PCD[1])
Fp = CP.PETSc2Scipy(PCD[2])
A = CP.PETSc2Scipy(A)
C = CP.PETSc2Scipy(C)
Fpinv = sp.linalg.inv(Fp)
Linv = sp.linalg.inv(L)
MO.StoreMatrix(L, "L")
MX = M + Dt * Linv * Dt.transpose()
MXinv = sp.linalg.inv(MX)
print(F + Ct * MXinv * Ct.transpose()).todense()
FX = F + Ct * MXinv * Ct.transpose()
PCD = Mp * Fpinv * Ap
#Finv = sp.linalg.inv(F)
#PCD = -C + Bt.transpose()*Finv*Bt
MO.StoreMatrix(Dt, "Dt")
MO.StoreMatrix(L, "L")
MO.StoreMatrix(Ct, "Ct")
MO.StoreMatrix(MX, "MX")
print FX.todense()
A = sp.bmat([[F, Ct, Bt, None], [Ct.transpose(), M, None, Dt],
[Bt.transpose(), None, None, None],
[None, Dt.transpose(), None, None]])
P = sp.bmat([[F, Bt, Ct, None], [None, -PCD, None, None],
[-Ct.transpose(), None, MX, None], [None, None, None, L]])
Pinner = sp.bmat([[F, Bt, None, None], [None, -PCD, None, None],
[None, None, MX, None], [None, None, None, L]])
Papprox = sp.bmat([[FX, Ct, Bt, None], [None, MX, None, Dt],
[None, None, -PCD, None], [None, None, None, L]])
print Papprox.todense()
return A, P, Pinner, Papprox
def eigens(A, W, PCD, KSPL):
IS = IndexSet(W)
F = A.getSubMatrix(IS[0], IS[0])
Ct = A.getSubMatrix(IS[0], IS[1])
Dt = A.getSubMatrix(IS[1], IS[3])
M = A.getSubMatrix(IS[1], IS[1])
Bt = A.getSubMatrix(IS[0], IS[2])
L = KSPL.getOperators()
C = A.getSubMatrix(IS[2], IS[2])
F = CP.PETSc2Scipy(F)
Ct = CP.PETSc2Scipy(Ct)
Dt = CP.PETSc2Scipy(Dt)
Bt = CP.PETSc2Scipy(Bt)
L = CP.PETSc2Scipy(L[0])
M = CP.PETSc2Scipy(M)
Ap = CP.PETSc2Scipy(PCD[0])
Mp = CP.PETSc2Scipy(PCD[1])
Fp = CP.PETSc2Scipy(PCD[2])
A = CP.PETSc2Scipy(A)
C = CP.PETSc2Scipy(C)
MO.StoreMatrix(Dt, "D")
ssss
Fpinv = sp.linalg.inv(Fp)
Linv = sp.linalg.inv(L)
MX = M + Dt * Linv * Dt.transpose()
MXinv = sp.linalg.inv(MX)
FX = F + Ct * MXinv * Ct.transpose()
PCD = Mp * Fpinv * Ap
Finv = sp.linalg.inv(F)
PCD = C + Bt.transpose() * Finv * Bt
# print P.toarray()
# print P.shape
# P = P.tocsc()
P = sp.bmat([[FX, Ct, Bt, None], [None, MX, None, None],
[None, None, -PCD, None], [None, None, None, L]])
return A, P
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.to_latex()
MO.StoreMatrix(DimSave, "dim")
# print " \n Outer Tol: ",OuterTol, "Inner Tol: ", InnerTol
# tableName = "2d_Lshaped_nu="+str(MU)+"_nu_m="+str(Mu_m)+"_kappa="+str(kappa)+"_l="+str(np.min(level))+"-"+str(np.max(level))+"Approx.tex"
# IterTable.to_latex(tableName)
# # # if (ShowResultPlots == 'yes'):
# plot(interpolate(u0,Velocity))
#
# u = plot(interpolate(u0,Velocity))
# p = plot(interpolate(pN2,Pressure))
# b = plot(interpolate(b0,Magnetic))
# u.write_png()
# p.write_png()
# b.write_png()
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)
PCD = [MatrixLinearFluids[0], MatrixLinearFluids[1], Fp]
print W
A, P = GE.eigens(A, W, PCD, HiptmairMatrices[4])
#A, P = GE.eigensApprox(A, W, PCD, HiptmairMatrices[4],HiptmairMatrices[6], FF)
#A, P = GE.eigens(A, W, PCD, kspMASS)
its = GE.ShiftedCDtest(FF)
os.chdir(path)
Mits += its
MO.StoreMatrix(A, "A_" + str(iter) + "_" + str(nn))
MO.StoreMatrix(P, "P_" + str(iter) + "_" + str(nn))
os.chdir('..')
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
print SolTime
import pandas as pd
axis=0)
x = IO.arrayToVec(uOld)
#F = IO.matToSparse(HiptmairMatrices[6]).tocsr()
#Finv = sp.linalg.inv(F)
#Finv = PETSc.Mat().createAIJ(size=Finv.shape,csr=(Finv.indptr, Finv.indices, Finv.data))
#Ct = A.getSubMatrix(u_is,b_is)
#C = A.getSubMatrix(b_is,u_is)
#print Ct.size
#Schur = A.getSubMatrix(u_is,u_is)-Ct*Finv*C
Schur = pc.getPythonContext().ExactReturn()
os.chdir(path)
ShiftedMass = ShiftedMass.sparray()
MO.StoreMatrix(ShiftedMass, "mass_" + str(iter) + "_" + str(nn))
MO.StoreMatrix(
IO.matToSparse(Schur).tocsr(),
"Schur_" + str(iter) + "_" + str(nn))
os.chdir('..')
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
print SolTime
Hdiv = FunctionSpace(mesh, 'BDM', order)
f = Expression(('(x[0])', '(x[1])'))
Ft = interpolate(f, Magnetic)
x = IO.arrayToVec(Ft.vector().array())
print x.array
Pxx = Px.createVecRight()
Px.multTranspose(x, Pxx)
Pyy = Py.createVecRight()
Py.multTranspose(x, Pyy)
PPP = CP.PETSc2Scipy(Px)
print(PPP * PPP.T).nnz
print(PPP * PPP.T).diagonal()
MO.StoreMatrix(PPP, "P")
P = np.concatenate((Pxx.array, Pyy.array), axis=1)
# print P
f = BCapply(Magnetic, BC[0], x, "dolfin")
fVec = interpolate(f, VecLagrange)
BC[2].apply(fVec.vector())
# plot(fVec, interactive=True)
uVec = FuncToPETSc(fVec)
for i in range(len(uVec.array)):
print uVec.array[i], ' ', P[i]
print uVec.array
print P
print np.max(abs(uVec.array - P))
#AA = CP.Assemble(assemble(inner(grad(t),grad(q))*dx))
print W
LL = HiptmairMatrices[4].getOperators()[0]
print LL
A = assemble(maxwell+ns+CoupleTerm)
A = CP.Assemble(A)
A, P, Pinner, Papprox = GE.eigensORIG(AA,A, W, PCD, M)
#A, P = GE.eigensApprox(A, W, PCD, HiptmairMatrices[4],HiptmairMatrices[6], FF)
#A, P = GE.eigens(A, W, PCD, kspMASS)
its = GE.ShiftedCDtest(FF)
path = 'TESTmatrix_kappa='+str(kappa)+'_nu_m='+str(Mu_m)+'_nu='+str(MU)
if not os.path.exists(path):
os.makedirs(path)
os.chdir(path)
Mits += its
MO.StoreMatrix(CP.PETSc2Scipy(M),"M_"+str(iter)+"_"+str(nn))
#MO.StoreMatrix(CP.PETSc2Scipy(AA),"LL_"+str(iter)+"_"+str(nn))
MO.StoreMatrix(A,"A_"+str(iter)+"_"+str(nn))
MO.StoreMatrix(CP.PETSc2Scipy(FF),"SM_"+str(iter)+"_"+str(nn))
MO.StoreMatrix(P,"P_"+str(iter)+"_"+str(nn))
MO.StoreMatrix(Pinner,"Pinner_"+str(iter)+"_"+str(nn))
MO.StoreMatrix(Papprox,"Papprox_"+str(iter)+"_"+str(nn))
os.chdir('..')
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
# MO.StoreMatrix(Acurl.sparray().tocsr(),"matrix/CurlCurl_n"+str(int(nn)))
# MO.StoreMatrix(Anode.sparray().tocsr(),"matrix/NodalLaplacian_n"+str(int(nn)))
# MO.StoreMatrix(C.tocsr(),"matrix/DiscreteGrad_n"+str(int(nn)))
C = scipy_csr_matrix2CrsMatrix(C, comm)
Acurl = scipy_csr_matrix2CrsMatrix(Acurl.sparray(), comm)
Anode = scipy_csr_matrix2CrsMatrix(Anode.sparray(), comm)
print "CurlCurl_n"+str(int(nn))
ML_Hiptmair = ML.MultiLevelPreconditioner(Acurl,C,Anode,MLList,False)
# ML_Hiptmair = ML.MultiLevelPreconditioner(Acurl,False)
ML_Hiptmair.ComputePreconditioner()
x = Function(Magnetic)
b_epetra = Epetra.Vector(b.array())
x_epetra = Epetra.Vector(0*b.array())
MO.StoreMatrix(b.array(),"matrix/RHS_n"+str(int(nn)))
scale = b_epetra.Norm2()
b_epetra =b_epetra/scale
import PyTrilinos.AztecOO as AztecOO
solver = AztecOO.AztecOO(Acurl, x_epetra, b_epetra)
solver.SetPrecOperator(ML_Hiptmair)
solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_cg_condnum );
solver.SetAztecOption(AztecOO.AZ_output, 1);
err = solver.Iterate(155000, 1e-5)
ItsSave[xx-1] = solver.NumIters()
TimeSave[xx-1] = solver.SolveTime()
x = Function(Magnetic)
x.vector()[:] = x_epetra.array*scale
# plot(x,interactive = True)