def test(d=1):
n = np.random.randint(low=3, high=10, size=d)
n = 3 * np.ones(d, dtype=int)
bounds = d * [np.array([-1, 1])]
if d > 1: bounds[-1] *= 100
expr = ''
for i in range(d):
expr += f"cos(pi*x{i})+"
expr = expr[:-1]
uex = anasol.AnalyticalSolution(expr, dim=d)
solvers = ["direct", "pyamg", "mg"]
solvers = ["pyamg", "mg"]
N, errs, its, ts = [], {}, {}, {}
for solver in solvers:
errs[solver], its[solver], ts[solver] = [], [], []
gold = None
while (1):
n = 2 * n - 1
g = grid.Grid(n=n, bounds=bounds)
if g.nall() > 2 * 1e6 or np.max(g.dx) < 1e-3: break
N.append(g.nall())
A = matrix.createMatrixDiff(g)
b = matrix.createRhsVectorDiff(g, uex)
if gold == None: u0 = np.zeros_like(b)
else: u0 = transfer.interpolate(gridf=g, gridc=gold, uold=uold)
for solver in solvers:
u, t, it = solve.solve(solver, A, b, x0=u0, grid=g)
err = errors.errorl2(g, u, uex)
errs[solver].append(err)
its[solver].append(it)
ts[solver].append(t)
uold, gold = u, g
print(f"its={its}")
fig = plt.figure()
ax = fig.add_subplot(311)
ax.set_xlabel(r'$\log_{10}(N)$')
ax.set_ylabel(r'$\log_{10}(e)$')
ax.set_title(f"{expr}")
for solver in solvers:
ax.plot(np.log10(N), np.log10(errs[solver]), '-x', label=f"{solver}")
ax.legend()
ax = fig.add_subplot(312)
ax.set_xlabel(r'$\log_{10}(N)$')
ax.set_ylabel(r'it')
ax.set_title(f"iter")
for solver in solvers:
ax.plot(np.log10(N), its[solver], '-x', label=f"{solver}")
ax.legend()
ax = fig.add_subplot(313)
ax.set_xlabel(r'$\log_{10}(N)$')
ax.set_ylabel(r't')
ax.set_title(f"time")
for solver in solvers:
ax.plot(np.log10(N), np.log10(ts[solver]), '-x', label=f"{solver}")
ax.legend()
plt.show()
def test(d=1):
n = np.random.randint(low=3,high=4, size=d)
bounds = d*[[-1,1]]
g = grid.Grid(n=n, bounds=bounds)
expr = ''
for i in range(d): expr += f"{np.random.randint(low=1,high=9)}*x{i}+"
uex = anasol.AnalyticalSolution(expr[:-1], dim=g.dim)
u = uex(g.coord())
err = errorl2(g, u, uex)
print(f"u={uex} grid={g}\nerr = {err:10.4e}")
def test(g, expr, solver='direct', uold=None, gold=None):
for i in range(g.dim):
g.bdrycond[i][0] = g.bdrycond[i][1] = 'dirichlet'
A = createMatrixDiff(g)
uex = anasol.AnalyticalSolution(expr, dim=g.dim)
b = createRhsVectorDiff(g, uex)
if gold == None:
u0 = np.zeros_like(b)
else:
u0 = transfer.interpolate(gridf=g, gridc=gold, uold=uold)
u, t, iter = solve.solve(solver, A, b, x0=u0, grid=g)
return errors.errorl2(grid=g, u=u, uex=uex), u, t, iter
def test(solvers, d=1):
n = np.random.randint(low=10,high=20, size=d)
bounds = d*[[-1,1]]
g = grid.Grid(n=n, bounds=bounds)
expr = ''
for i in range(d): expr += f"{np.random.randint(low=1,high=9)}*x{i}+"
uex = anasol.AnalyticalSolution(expr[:-1], dim=g.dim)
A = matrix.createMatrixDiff(g)
b = matrix.createRhsVectorDiff(g, uex)
for solver in solvers:
u, t, iter = solve(solver, A, b, grid=g)
err = errors.errorl2(g, u, uex)
print(f"grid={g}\nsolver = {solver}\terr = {err:10.4e}\t time = {t}\t iter = {iter}")
def test(d=1):
n = np.random.randint(low=4, high=8, size=d)
bounds = d * [[-1, 1]]
g = grid.Grid(n=n, bounds=bounds)
expr = ''
for i in range(d):
expr += f"{np.random.randint(low=1,high=9)}*x{i}+"
uex = anasol.AnalyticalSolution(expr[:-1], dim=g.dim)
A = matrix.createMatrixDiff(g)
b = matrix.createRhsVectorDiff(g, uex)
u = splinalg.spsolve(A, b)
err = errors.errorl2(g, u, uex)
print(f"u={uex} grid={g}\nerr = {err:10.4e}")
def test(d=1):
n = np.random.randint(low=3, high=4, size=d)
bounds = d * [[-1, 1]]
expr = ''
for i in range(d):
expr += f"cos(pi*x{i})+"
expr = expr[:-1]
uex = anasol.AnalyticalSolution(expr, dim=d)
N, errs, its, ts = [], [], [], []
gold = None
for k in range(2 * (6 - d)):
n = 2 * n - 1
g = grid.Grid(n=n, bounds=bounds)
A = matrix.createMatrixDiff(g)
b = matrix.createRhsVectorDiff(g, uex)
if gold == None: u0 = np.zeros_like(b)
else: u0 = transfer.interpolate(gridf=g, gridc=gold, uold=uold)
u, t, it = solve.solve("pyamg", A, b, x0=u0)
err = errors.errorl2(g, u, uex)
uold, gold = u, g
N.append(g.nall())
errs.append(err)
its.append(it)
ts.append(t)
# print(f"u={uex} grid={g}\nerr = {err:10.4e}")
slope, ic, r, p, stderr = stats.linregress(np.log10(N), np.log10(errs))
# print(f"y = {slope:4.2f} * x {ic:+4.2f}")
fig = plt.figure()
ax = fig.add_subplot(211)
ax.set_xlabel(r'$\log_{10}(N)$')
ax.set_ylabel(r'$\log_{10}(e)$')
ax.set_title(f"{expr}")
ax.plot(np.log10(N), np.log10(errs), '-x', label=f"err")
ax.plot(np.log10(N),
ic + slope * np.log10(N),
'-k',
label=f"y = {slope:4.2f} * x {ic:+4.2f}")
ax.legend()
ax = fig.add_subplot(212)
ax.set_xlabel(r'$\log_{10}(N)$')
ax.set_ylabel(r'it', color='b')
p0, = ax.plot(np.log10(N), its, '-xb', label=f"it")
ax.set_title(f"iter/time")
axt = ax.twinx()
p1, = axt.plot(np.log10(N), np.log10(ts), '-xr', label=f"t")
axt.set_ylabel(r'$\log_{10}(t)$', color='r')
ax.tick_params(axis='y', labelcolor='b')
axt.tick_params(axis='y', labelcolor='r')
plt.legend(handles=[p0, p1])
plt.show()
def testtocell(d=1):
g = grid.Grid(d * [3], bounds=d * [[-1, 1]])
expr = ''
for i in range(d):
expr += f"{np.random.randint(low=1,high=9)}*x{i}+"
uex = anasol.AnalyticalSolution(expr[:-1], dim=d)
u = uex(g.coord())
# print(f"grid = {g}\nuex={uex}\nu={u}")
uc = tocell(g, u)
fig = plt.figure()
ax = fig.add_subplot(2, 1, 1)
plotgrid.plot(g, ax=ax, u=u, title=f"d={d}")
ax = fig.add_subplot(2, 1, 2)
plotgrid.plot(g, ax=ax, u=uc, title=f"d={d}", celldata=True)
plt.show()
#=================================================================#
class MgDriver(mg.FdDriver):
def __init__(self, grid, A, **kwargs):
maxlevel=-10000
if grid.dim == 1: maxlevel = -100
super().__init__(grid, A=A, smoothers=['lgs'], maxlevel=maxlevel)
#=================================================================#
def solve(A, b, grid, x0=None, verbose=True):
mgD = MgDriver(grid, A)
mgS = mg.MultiGrid(mgD)
return mgS.solve(b, x0=x0, verbose=verbose)
#=================================================================#
if __name__ == '__main__':
import matplotlib.pyplot as plt
d, l = 3, 6
expr = ''
for i in range(d): expr += f"log(1+x{i}**2)*"
expr = expr[:-1]
uex = anasol.AnalyticalSolution(expr, dim=d)
bounds=d*[[-1,1]]
grid = grid.Grid(n=np.array(d*[2**l+1]), bounds=bounds)
print(f"uex = {uex} N={grid.nall()}")
b = matrix.createRhsVectorDiff(grid, uex)
A = matrix.createMatrixDiff(grid)
u, res = solve(A, b, grid)
plotgrid.plot(grid, u=u)
plt.show()
def testprolongation(ns, bounds, expr, fcts, transpose=False):
import time
d = len(bounds)
uex = anasol.AnalyticalSolution(expr, dim=d)
print(f"uex={uex}")
grids = []
for n in ns:
grids.append(grid.Grid(n, bounds=bounds))
intsimp = InterpolateSimple(grids)
times = {}
for fct in fcts:
times[fct] = []
N = []
if transpose:
args = "(gridf = gf, gridc = gc, uold=uc, level=l+1)"
argsT = "(gridf = gf, gridc = gc, uold=uf, level=l+1, transpose=True)"
for l in range(len(grids) - 1):
gc = grids[l]
gf = grids[l + 1]
N.append(gf.nall())
uf = np.random.random(gf.nall())
uc = np.random.random(gc.nall())
uc = np.linspace(0, 1, gc.nall())
uf = np.ones(gf.nall())
for fct in fcts:
print(fct)
t0 = time.time()
# uf2 = eval(fct+args)
# print(f"AVANT uf2 = {uf2} ({id(uf2)}) {adress(uf2)}")
uc2 = eval(fct + argsT)
# print(f"uc = {uc}\nuc2 = {uc2} ({id(uc2)})")
# print(f"uc={uc.shape} uc2={uc2.shape}")
uf2 = eval(fct + args)
# print(f"APRES uf2 = {uf2} ({id(uf2)}) {adress(uf2)}")
times[fct].append(time.time() - t0)
# print(f"uc={uc.shape} uc2={uc2.shape}")
suc, suf = uc2.dot(uc), uf2.dot(uf)
if abs(suc - suf) > 1e-14 * uc.dot(uc):
print(f"uc2*uc = {suc} uf2*uf = {suf}")
raise ValueError(f"bug in restrict {abs(suc-suf)}")
else:
args = "(gridf = gf, gridc = gc, uold=uc, level=l+1)"
uc = uex(*grids[0].coord())
for l in range(len(grids) - 1):
gc = grids[l]
gf = grids[l + 1]
N.append(gf.nall())
for fct in fcts:
print(fct)
t0 = time.time()
uf = eval(fct + args)
times[fct].append(time.time() - t0)
error(gf, uf, uex)
uc = uf
for fct in fcts:
plt.plot(np.log10(N), np.log10(times[fct]), 'x-', label=fct)
plt.title(f"d={d}")
plt.legend()
plt.xlabel("log10(n)")
plt.ylabel("log10(t)")
plt.show()