def fit(X, Y, sigma, lmbda, L_X, L_Y, cg_tol=1e-3, cg_maxiter=None, alpha0=None):
if cg_maxiter is None:
# CG needs at max dimension many iterations
cg_maxiter = L_X.shape[0]
NX = X.shape[0]
# set up and solve regularised linear system via bicgstab
# this never stores an NxN matrix
b = compute_b(X, Y, L_X, L_Y, sigma)
matvec = lambda v: apply_left_C(v, X, Y, L_X, L_Y, lmbda)
C_operator = LinearOperator((NX, NX), matvec=matvec, dtype=np.float64)
# for printing number of CG iterations
global counter
counter = 0
def callback(x):
global counter
counter += 1
# start optimisation from alpha0, if present
if alpha0 is not None:
logger.debug("Starting bicgstab from previous alpha0")
solution, info = bicgstab(C_operator, b, tol=cg_tol, maxiter=cg_maxiter, callback=callback, x0=alpha0)
logger.debug("Ran bicgstab for %d iterations." % counter)
if info > 0:
logger.warning("Warning: CG not convergence in %.3f tolerance within %d iterations" % (cg_tol, cg_maxiter))
a = -sigma / 2.0 * solution
return a
def fit_sym(Z, sigma, lmbda, L, cg_tol=1e-3, cg_maxiter=None):
if cg_maxiter is None:
# CG needs at max dimension many iterations
cg_maxiter = L.shape[0]
N = Z.shape[0]
# set up and solve regularised linear system via bicgstab
# this never stores an NxN matrix
b = compute_b_sym(Z, L, sigma)
matvec = lambda v: apply_left_C_sym(v, Z, L, lmbda)
C_operator = LinearOperator((N, N), matvec=matvec, dtype=np.float64)
solution, info = bicgstab(C_operator, b, tol=cg_tol, maxiter=cg_maxiter)
if info > 0:
print "Warning: CG not terminated within specified %d iterations" % cg_maxiter
a = -sigma / 2.0 * solution
return a
def fit(X,
Y,
sigma,
lmbda,
L_X,
L_Y,
cg_tol=1e-3,
cg_maxiter=None,
alpha0=None):
if cg_maxiter is None:
# CG needs at max dimension many iterations
cg_maxiter = L_X.shape[0]
NX = X.shape[0]
# set up and solve regularised linear system via bicgstab
# this never stores an NxN matrix
b = compute_b(X, Y, L_X, L_Y, sigma)
matvec = lambda v: apply_left_C(v, X, Y, L_X, L_Y, lmbda)
C_operator = LinearOperator((NX, NX), matvec=matvec, dtype=np.float64)
# for printing number of CG iterations
global counter
counter = 0
def callback(x):
global counter
counter += 1
# start optimisation from alpha0, if present
if alpha0 is not None:
logger.debug("Starting bicgstab from previous alpha0")
solution, info = bicgstab(C_operator,
b,
tol=cg_tol,
maxiter=cg_maxiter,
callback=callback,
x0=alpha0)
logger.debug("Ran bicgstab for %d iterations." % counter)
if info > 0:
logger.warning("Warning: CG not convergence in %.3f tolerance within %d iterations" % \
(cg_tol, cg_maxiter))
a = -sigma / 2. * solution
return a
def score_matching_low_rank(X, Y, sigma, lmbda, L_X, L_Y,
cg_tol=1e-3,
cg_maxiter=None):
if cg_maxiter is None:
# CG needs at max dimension many iterations
cg_maxiter = L_X.shape[0]
NX = X.shape[0]
# set up and solve regularised linear system via bicgstab
# this never stores an NxN matrix
b = _compute_b_low_rank(X, Y, L_X, L_Y, sigma)
matvec = lambda v:_apply_left_C_low_rank(v, X, Y, L_X, L_Y, lmbda)
C_operator = LinearOperator((NX, NX), matvec=matvec, dtype=np.float64)
solution, info = bicgstab(C_operator, b, tol=cg_tol, maxiter=cg_maxiter)
if info > 0:
print "Warning: CG not terminated within specified %d iterations" % cg_maxiter
a = -sigma / 2. * solution
return a
def fit_sym(Z, sigma, lmbda, L,
cg_tol=1e-3,
cg_maxiter=None):
if cg_maxiter is None:
# CG needs at max dimension many iterations
cg_maxiter = L.shape[0]
N = Z.shape[0]
# set up and solve regularised linear system via bicgstab
# this never stores an NxN matrix
b = compute_b_sym(Z, L, sigma)
matvec = lambda v:apply_left_C_sym(v, Z, L, lmbda)
C_operator = LinearOperator((N, N), matvec=matvec, dtype=np.float64)
solution, info = bicgstab(C_operator, b, tol=cg_tol, maxiter=cg_maxiter)
if info > 0:
print "Warning: CG not terminated within specified %d iterations" % cg_maxiter
a = -sigma / 2. * solution
return a
momY_M = Myc - Myd
# RHS:
momX_F = -(Fxc - Fxd) - gradP[:, 0] * mesh.cells_areas
momY_F = -(Fyc - Fyd) - gradP[:, 1] * mesh.cells_areas
print "Initial continuity residual:", np.linalg.norm(edgeDiv(phi)) # spr spelnienie RC w obszarze
print "Initial Ux residual:", np.linalg.norm(momX_M.dot(Ux.data) - momX_F)
print "Initial Uy residual:", np.linalg.norm(momY_M.dot(Uy.data) - momY_F)
momX_M.relaxM1(momX_F, Ux, mom_relax)
momY_M.relaxM1(momY_F, Uy, mom_relax)
# 2. rozwiazuje rownania pedu:
# obliczam i uaktualniam pole predkosci (setValues()):
Ux.setValues(bicgstab(A=momX_M.sparse, b=momX_F, x0=Ux.data, tol=1e-8)[0])
Uy.setValues(bicgstab(A=momY_M.sparse, b=momY_F, x0=Uy.data, tol=1e-8)[0])
edgeU = EdgeField.vector(einterp(Ux), einterp(Uy)) # pole predkosci na krawedziach my mamy w centrach (tak ukladam i rozwiazuje uklad rownan)
phi = edgeU.dot(mesh.normals)
A = np.array([np.array(momX_M.diag), np.array(momY_M.diag)]).T
coeffFieldX = SurfField(mesh, Neuman)
coeffFieldX.setValues(mesh.cells_areas / A[:, 0])
coeffFieldY = SurfField(mesh, Neuman)
coeffFieldY.setValues(mesh.cells_areas / A[:, 1])
coeffEdge = EdgeField.vector(EdgeField.interp(coeffFieldX), EdgeField.interp(coeffFieldY)) # interpoluje wsp ze srodkow komorek na fejsy
# print "Mc diag", Mc.diag # print "Mc data",Mc.data # # print "Md data",Md.data # print "Md diag",Md.diag # print "Fc",Fc # print "Fd",Fd # print "F",F # print "M data",M.data # print "M diag",M.diag # print M.sparse res, info = bicgstab(A=M.sparse, b=F, x0=T.data, tol=1e-8, maxiter=250e3) T.setValues(res) print ">>>> info: ", info # animate_contour_plot([T.data.reshape(n, n)], skip=10, repeat=False, interval=75) animate_contour_plot([inter(mesh.xy, mesh.cells, T.data).reshape((n+1, n+1))], skip=10, nLevels=16, repeat=False, interval=75, nN=n, diff=diffusivity, adj=adj) # magU = np.sqrt(Ux.data**2 + Uy.data**2) # print magU.shape, n*n, Ux.data.shape # animate_contour_plot([magU.reshape(n, n)], skip=10, repeat=False, interval=75) plt.show()
print ">>>> Equations generated in " , time.clock()-start
start = time.clock()
Results = list()
Tn = T.data.reshape((n, n))
Results.append(Tn)
from scipy.sparse.linalg.isolve.iterative import bicgstab
licznik = 0
step = 10
for iter in range(int(nt)):
licznik = licznik + 1
solution = bicgstab(A=M.sparse, b=F + source(mesh, T.data/dt), x0=T.data, tol=1e-8)[0]
T.setValues(solution)
if licznik == step:
Results.append(T.data.reshape((n, n)))
licznik = 0
step += 10 + 1
print "pozostalo: ", int(nt - iter)
anim = animate_contour_plot(Results, skip=2, repeat=False, interval=75, nLevels=20, nN=n, dataRange=[0., 10], diff=diffusivity, dt=dt, adj=adj)
# from interpolacja import inter
# from matplotlib.pyplot import quiver
# q = quiver(mesh.cell_centers[:, 0], mesh.cell_centers[:, 1], Ux[:], Uy[:])
# animate_contour_plot([inter(mesh.xy, mesh.cells, T.data).reshape((n+1, n+1))], skip=10, repeat=False, interval=75, dataRange=[0, 10])
momY_M = Myc - Myd * viscosity
momX_F = -(Fxc - Fxd * viscosity) - gradP[:, 0]*mesh.cells_areas
momY_F = -(Fyc - Fyd * viscosity) - gradP[:, 1]*mesh.cells_areas
# momX_M = Mxd * (-viscosity)
# momY_M = Myd * (-viscosity)
#
# momX_F = Fxd * viscosity - gradP[:, 0]*mesh.cells_areas
# momY_F = Fyd * viscosity - gradP[:, 1]*mesh.cells_areas
momX_M.relax(0.7)
momY_M.relax(0.7)
xSol = bicgstab(A=momX_M.sparse, b=momX_F, x0=Ux.data)[0]
ySol = bicgstab(A=momY_M.sparse, b=momY_F, x0=Uy.data)[0]
Ux.setValues(xSol)
Uy.setValues(ySol)
# Ux.setValues(0.3*Ux.data + 0.7*xSol)
# Uy.setValues(0.3*Uy.data + 0.7*ySol)
A = np.array(momX_M.diag)
Hx = - momX_M.offdiagmul(Ux.data) # offdiagnal to sąsiedzi
Hy = - momY_M.offdiagmul(Uy.data)
# tmpX = Ux.data
# tmpY = Uy.data
M = I - M
print ">>>> Equations generated in " , time.clock()-start
start = time.clock()
Results = list()
Tn = T.data.reshape((n, n))
Results.append(Tn)
from scipy.sparse.linalg.isolve.iterative import bicgstab
for iter in range(nt):
print 'time iteration:',iter
T.setValues( bicgstab(A=M.sparse, b=F+T.data*mesh.cells_areas/dt, x0=T.data, tol=1e-8)[0] )
Tn = T.data.reshape((n, n))
Results.append(Tn)
print ">>>> Solved in ", time.clock()-start
# Animate results:
import matplotlib.pyplot as plt
# X, Y = np.meshgrid(np.linspace(0, 1, n), np.linspace(0, 1, n))
# fig = plt.figure()
# plt.axes().set_aspect('equal', 'datalim')
# ticks = np.linspace(0, 10, 11)
# cs = plt.contourf(X, Y, T.data.reshape((n,n)), )
# cbar = fig.colorbar(cs, ticks=ticks)
Results = list()
Tn = T.data.reshape((n, n))
Results.append(Tn)
from scipy.sparse.linalg.isolve.iterative import bicgstab
for iter in range(int(nt)):
print 'time iteration:',iter
F = Fconst + T.data
# T.data = np.array(np.linalg.solve(M, F))
T.data = bicgstab(A=M.sparse, b=F, x0=T.data)[0]
T.data = T.data.reshape((len(F), 1))
Tn = T.data.reshape((n, n))
Results.append(Tn)
# Animate results:
#animate_contour_plot(Results, skip=10, repeat=False, interval=75, dataRange=[0, 10])
gradT = cellGrad(T) # liczymy gradienty obliczonych wartosci temp do wizualizacji
from interpolacja import inter
from matplotlib.pyplot import quiver
from matplotlib.pyplot import contourf
from numpy import meshgrid
