def Solve(a, f, c, ms=100, tol=1e-12, nocb=True): ngs.ngsglobals.msg_level = 5 gfu = ngs.GridFunction(a.space) with ngs.TaskManager(): a.Assemble() f.Assemble() ngs.ngsglobals.msg_level = 1 c.Test() cb = None if a.space.mesh.comm.rank != 0 or nocb else lambda k, x: print( "it =", k, ", err =", x) cg = ngs.krylovspace.CGSolver(mat=a.mat, pre=c, callback=cb, maxsteps=ms, tol=tol) ngs.mpi_world.Barrier() ts = ngs.mpi_world.WTime() cg.Solve(sol=gfu.vec, rhs=f.vec) ngs.mpi_world.Barrier() ts = ngs.mpi_world.WTime() - ts if ngs.mpi_world.rank == 0: print("---") print("multi-dim ", a.space.dim) print("(vectorial) ndof ", a.space.ndofglobal) print("(scalar) ndof ", a.space.dim * a.space.ndofglobal) print("used nits = ", cg.iterations) print("(vec) dofs / (sec * np) = ", a.space.ndofglobal / (ts * max(ngs.mpi_world.size - 1, 1))) print("(scal) dofs / (sec * np) = ", (a.space.ndofglobal * a.space.dim) / (ts * max(ngs.mpi_world.size - 1, 1))) print("---") assert cg.errors[-1] < tol * cg.errors[0] assert cg.iterations < ms return gfu
def test_h1_real(): """Test h1 amg for real example.""" with ngs.TaskManager(): mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2)) fes = ngs.H1(mesh, dirichlet=[1, 2, 3], order=1) u = fes.TrialFunction() v = fes.TestFunction() # rhs f = ngs.LinearForm(fes) f += ngs.SymbolicLFI(v) f.Assemble() # lhs a = ngs.BilinearForm(fes, symmetric=True) a += ngs.SymbolicBFI(grad(u) * grad(v)) c = ngs.Preconditioner(a, 'h1amg2') a.Assemble() solver = ngs.CGSolver(mat=a.mat, pre=c.mat) gfu = ngs.GridFunction(fes) gfu.vec.data = solver * f.vec assert_greater(solver.GetSteps(), 0) assert_less_equal(solver.GetSteps(), 4)
def apply_inverse(self, V, mu=None, least_squares=False, default_solver=''): assert V in self.range if least_squares: raise NotImplementedError solver = self.solver_options.get('inverse', default_solver) if self.solver_options else default_solver R = self.source.zeros(len(V)) with ngs.TaskManager(): inv = self.matrix.Inverse(self.source.V.FreeDofs(), inverse=solver) for r, v in zip(R._list, V._list): r.impl.vec.data = inv * v.impl.vec return R
def test_parallel(): mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2)) fes = ngs.L2(mesh, order=5, complex=True) g1 = ngs.GridFunction(fes) g2 = ngs.GridFunction(fes) for order in range(10): functions = [(f(ngs.x + 1j * ngs.y, order)) for f in fs_ng] for f in functions: g1.Set(f) with ngs.TaskManager(): g2.Set(f) error = ngs.Integrate(g1 - g2, mesh) assert error == 0j
"""Solve simple laplace equation on a square.""" # pylint: disable=no-member from ctypes import CDLL import ngsolve as ngs from ngsolve import grad from netgen.geom2d import unit_square CDLL('libh1amg.so') with ngs.TaskManager(): mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.2)) fes = ngs.H1(mesh, dirichlet=[1, 2, 3], order=1) u = fes.TrialFunction() v = fes.TestFunction() # rhs f = ngs.LinearForm(fes) f += ngs.SymbolicLFI(v) # lhs a = ngs.BilinearForm(fes, symmetric=True) a += ngs.SymbolicBFI(grad(u) * grad(v)) c = ngs.Preconditioner(a, 'h1amg', test=True) gfu = ngs.GridFunction(fes)
"ngs_amg_enable_redist": True, "ngs_amg_first_aaf": 0.025 } gfu = ngsolve.GridFunction(V) a.Assemble() f.Assemble() gfu.vec.data = a.mat.Inverse(V.FreeDofs()) * f.vec #ngsolve.Draw(mesh, deformation = ngsolve.CoefficientFunction((gfu[0], gfu[1], gfu[2])), name="defo") ngsolve.Draw(mesh, deformation=ngsolve.CoefficientFunction((gfu[0], gfu[1])), name="defo") ngsolve.Draw(gfu[2], mesh, name="rot") # for i in range(6): # ngsolve.Draw(gfu[i], mesh, name="comp_"+str(i)) # ngsolve.Draw(gfu, name="sol") # # c = ngsolve.Preconditioner(a, "ngs_amg.elast3d", **pc_opts) c = ngs_amg.elast_3d(a, **pc_opts) pt = 0 #100 * 1024 * 1024 with ngsolve.TaskManager(pajetrace=pt): Solve(a, f, c, ms=40) # if ngsolve.mpi_world.rank == 1: #SetNumThreads(5) #from bftester_vec import shape_test #shape_test(mesh, maxh, V, a, c, 6)
def solve(self): # disable garbage collector # --------------------------------------------------------------------# gc.disable() while (gc.isenabled()): time.sleep(0.1) # --------------------------------------------------------------------# # measure how much memory is used until here process = psutil.Process() memstart = process.memory_info().vms # starts timer tstart = time.time() if self.show_gui: import netgen.gui # create mesh with initial size 0.1 self._mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.1)) #create finite element space self._fes = ngs.H1(self._mesh, order=2, dirichlet=".*", autoupdate=True) # test and trail function u = self._fes.TrialFunction() v = self._fes.TestFunction() # create bilinear form and enable static condensation self._a = ngs.BilinearForm(self._fes, condense=True) self._a += ngs.grad(u) * ngs.grad(v) * ngs.dx # creat linear functional and apply RHS self._f = ngs.LinearForm(self._fes) self._f += (-4) * v * ngs.dx # preconditioner: multigrid - what prerequisits must the problem have? self._c = ngs.Preconditioner(self._a, "multigrid") # create grid function that holds the solution and set the boundary to 0 self._gfu = ngs.GridFunction(self._fes, autoupdate=True) # solution self._g = self._ngs_ex self._gfu.Set(self._g, definedon=self._mesh.Boundaries(".*")) # draw grid function in gui if self.show_gui: ngs.Draw(self._gfu) # create Hcurl space for flux calculation and estimate error self._space_flux = ngs.HDiv(self._mesh, order=2, autoupdate=True) self._gf_flux = ngs.GridFunction(self._space_flux, "flux", autoupdate=True) # TaskManager starts threads that (standard thread nr is numer of cores) with ngs.TaskManager(): # this is the adaptive loop while self._fes.ndof < self.max_ndof: self._solveStep() self._estimateError() self._mesh.Refine() # since the adaptive loop stopped with a mesh refinement, the gfu must be # calculated one last time self._solveStep() if self.show_gui: ngs.Draw(self._gfu) # set measured exectution time self._exec_time = time.time() - tstart # set measured used memory memstop = process.memory_info().vms - memstart self._mem_consumption = memstop # enable garbage collector # --------------------------------------------------------------------# gc.enable() gc.collect()