def presets_load_coefficientfunction_into_gridfunction(): # 2D mesh_2d = ngs.Mesh(unit_square.GenerateMesh(maxh=0.1)) fes_scalar_2d = ngs.H1(mesh_2d, order=2) fes_vector_2d = ngs.HDiv(mesh_2d, order=2) fes_mixed_2d = ngs.FESpace([fes_vector_2d, fes_scalar_2d]) # 3D geo_3d = CSGeometry() geo_3d.Add(OrthoBrick(Pnt(-1, 0, 0), Pnt(1, 1, 1)).bc('outer')) mesh_3d = ngs.Mesh(geo_3d.GenerateMesh(maxh=0.3)) fes_scalar_3d = ngs.H1(mesh_3d, order=2) fes_vector_3d = ngs.HDiv(mesh_3d, order=2) fes_mixed_3d = ngs.FESpace([fes_vector_3d, fes_scalar_3d]) return mesh_2d, fes_scalar_2d, fes_vector_2d, fes_mixed_2d, mesh_3d, fes_scalar_3d, fes_vector_3d, fes_mixed_3d
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 setup_poisson(mesh, alpha=1, beta=0, f=1, diri=".*", order=1, fes_opts=dict(), blf_opts=dict(), lf_opts=dict()): V = ngs.H1(mesh, order=order, dirichlet=diri, **fes_opts) u, v = V.TnT() a = ngs.BilinearForm(V, **blf_opts) a += ngs.SymbolicBFI(alpha * ngs.grad(u) * ngs.grad(v)) if beta != 0: a += ngs.SymbolicBFI(beta * u * v) lf = ngs.LinearForm(V) lf += ngs.SymbolicLFI(f * v) return V, a, lf
def systems_and_preconditioners(mesh, X, z, order=1): # Create a real analogue of our vector space for the wrapper preconditioner. dirichlet = 'top|right|bottom|left' X_real = ng.H1(mesh, order=order, dirichlet=dirichlet, complex=False) # Test and trial functions for the original space. u, v = X.TnT() # Real trial and test functions. ur, vr = X_real.TnT() # Create a real analogue of the bilinear form a. a_real = ng.BilinearForm(X_real) a_real += ng.SymbolicBFI(ng.grad(ur) * ng.grad(vr)) a_real.Assemble() # Initialize petsc prior to conswtructing preconditioners. petsc.Initialize() # Create a bilinear form and a preconditioner for each z. zbas = [] precs = [] for k in range(len(z)): # Create a bilinear form for the given z-value. zba = ng.BilinearForm(X) zba += ng.SymbolicBFI(z[k] * u * v - ng.grad(u) * ng.grad(v)) # Create a preconditioner for the given z-value. mat_convert = petsc.PETScMatrix(a_real.mat, freedofs=X_real.FreeDofs()) real_pc = petsc.PETSc2NGsPrecond(mat=mat_convert, name="real_pc", petsc_options={"pc_type": "gamg"}) prec = WrapperPrec(real_pc) # Assemble the given bilinear form. zba.Assemble() # Tack the bilinear forms and preconditioners onto their respective lists. zbas += [zba] precs += [prec] return zbas, precs
def spaces_and_forms(mesh, order=1): # Create a distributed finite element space. dirichlet = 'top|right|bottom|left' X = ng.H1(mesh, order=order, dirichlet=dirichlet, complex=True) # Create the test and trial functions. u, v = X.TnT() # Create the bilinear form for the left-hand-side. a = ng.BilinearForm(X) a += ng.SymbolicBFI(ng.grad(u) * ng.grad(v)) a.Assemble() # Create the second needed bilinear form as is needed for FEAST. b = ng.BilinearForm(X) b += ng.SymbolicBFI(u * v) b.Assemble() return X, a, b
def setup_norot_elast(mesh, mu=1, lam=0, f_vol=None, multidim=True, reorder=False, diri=".*", order=1, fes_opts=dict(), blf_opts=dict(), lf_opts=dict()): dim = mesh.dim if multidim: V = ngs.H1(mesh, order=order, dirichlet=diri, **fes_opts, dim=mesh.dim) else: V = ngs.VectorH1(mesh, order=order, dirichlet=diri, **fes_opts) if reorder: raise Exception( "reordered does not work anymore (now ordered by elements)!!") V = ngs.comp.Reorder(V) u, v = V.TnT() sym = lambda X: 0.5 * (X + X.trans) grd = lambda X: ngs.CoefficientFunction(tuple( ngs.grad(X)[i, j] for i in range(dim) for j in range(dim)), dims=(dim, dim)) eps = lambda X: sym(grd(X)) a = ngs.BilinearForm(V, symmetric=False, **blf_opts) a += mu * ngs.InnerProduct(eps(u), eps(v)) * ngs.dx if lam != 0: div = lambda U: sum([ngs.grad(U)[i, i] for i in range(1, dim)], start=ngs.grad(U)[0, 0]) a += lam * div(u) * div(v) * ngs.dx lf = ngs.LinearForm(V) lf += f_vol * v * ngs.dx return V, a, lf
k_iso = ng.CoefficientFunction(384.) # thermal conductivity [W/(m*K)] alpha = ng.CoefficientFunction( 3.9e-3) # coefficient for T-dependent resistivity [1/K] t_max = 2000. # time in s dt = 50. # time step num_steps = int(t_max / dt) # temperature-dependent resistivity def sigma_T(Temp): return ng.CoefficientFunction(1. / (rho_0 * (1. + alpha * (Temp - T_0)))) # declare function space V = ng.H1(mesh, order=order, dirichlet="left|right") VT = ng.H1(mesh, order=order, dirichlet="left|right|circle") print("Number of DOFs: {}".format(V.ndof)) # boundary conditions # Dirichlet for assigned electric potential bc_values_pot = {"top": V0, "bottom": f, "circle": 0, "left": V0, "right": f} bc_cf_pot = ng.CoefficientFunction( [bc_values_pot[bc] for bc in mesh.GetBoundaries()]) # Dirichlet for assigned temperature bc_values_T = { "top": T_0, "bottom": T_0, "circle": T_0, "left": T_0,
def get_DIM_gridfunctions(self, mesh: ngs.Mesh, interp_ord: int): """ Function to get all of the phase fields and masks as gridfunctions. This is either done by loading them from files or by constructing the numpy arrays and then converting those into gridfunctions. Args: mesh: The mesh for the gridfunctions. interp_ord: The interpolant order for the finite element space for the gridfunctions. """ if self.load_method == 'file': # The phase field and masks have already been created and saved as gridfunctions. fes = ngs.H1(mesh, order=interp_ord) phi_filename = self.config.get_item( ['PHASE FIELDS', 'phi_filename'], str) self.phi_gfu = create_and_load_gridfunction_from_file( phi_filename, fes) if self.multiple_bcs: # There are BC masks that must be loaded. for marker, filename in self.vertices.items(): mask_gfu = create_and_load_gridfunction_from_file( filename, fes) self.mask_gfu_dict[marker] = mask_gfu else: # One single mask that is just a grid function of ones. mask_gfu = ngs.GridFunction(fes) mask_gfu.Set(1.0) self.mask_gfu_dict['all'] = mask_gfu # Construct Grad(phi) and |Grad(phi)|. self.grad_phi_gfu = ngs.Grad(self.phi_gfu) self.mag_grad_phi_gfu = ngs.Norm(ngs.Grad(self.phi_gfu)) else: # The phase field and masks must be generated as numpy arrays and then converted into gridfunctions. # The phase field array has already been generated because it is needed to generate the mesh. # Construct the phase field, Grad(phi), and |Grad(phi)|. if self.N == self.N_mesh: # phi was generated on the simulation mesh, so just load phi into a gridfunction and compute Grad(phi) # and |Grad(phi)|. self.phi_gfu = numpy_to_NGSolve(self.mesh, interp_ord, self.phi_arr, self.scale, self.offset, self.dim) self.grad_phi_gfu = ngs.Grad(self.phi_gfu) self.mag_grad_phi_gfu = ngs.Norm(ngs.Grad(self.phi_gfu)) else: # phi was generated on a refined mesh, so load it into a refined mesh gridfunction, compute Grad(phi) # and |Grad(phi)|, then project all three into gridfunctions defined on the simulation mesh. phi_gfu_tmp = numpy_to_NGSolve(self.mesh_refined, interp_ord, self.phi_arr, self.scale, self.offset, self.dim) grad_phi_gfu_tmp = ngs.Grad(phi_gfu_tmp) mag_grad_phi_gfu_tmp = ngs.Norm(ngs.Grad(phi_gfu_tmp)) # Now project onto the coarse simulation mesh. fes = ngs.H1(mesh, order=interp_ord) vec_fes = ngs.VectorH1(mesh, order=interp_ord) self.phi_gfu = ngs.GridFunction(fes) self.grad_phi_gfu = ngs.GridFunction(vec_fes) self.mag_grad_phi_gfu = ngs.GridFunction(fes) self.phi_gfu.Set(phi_gfu_tmp) self.grad_phi_gfu.Set(grad_phi_gfu_tmp) self.mag_grad_phi_gfu.Set(mag_grad_phi_gfu_tmp) if self.multiple_bcs: # There are multiple BC masks that must be generated and loaded. for marker, mask_arr in self.mask_arr_dict.items(): mask_gfu = numpy_to_NGSolve(mesh, interp_ord, mask_arr, self.scale, self.offset, self.dim) self.mask_gfu_dict[marker] = mask_gfu else: # One single mask that is just a grid function of ones. mask_arr = np.ones(tuple([int(n + 1) for n in self.N])) mask_gfu = numpy_to_NGSolve(mesh, interp_ord, mask_arr, self.scale, self.offset, self.dim) self.mask_gfu_dict['all'] = mask_gfu # Save the gridfunctions if desired. save_to_file = self.config.get_item( ['PHASE FIELDS', 'save_to_file'], bool) if save_to_file: self.phi_gfu.Save(self.DIM_dir + '/phi.sol') self.ngmesh.Save(self.DIM_dir + '/mesh.vol') for marker, gfu in self.mask_gfu_dict.items(): # Save the BC masks inside the DIM bc_dir. gfu.Save(self.DIM_dir + '/bc_dir/{}_mask.sol'.format(marker))
from regpy.hilbert import L2 from regpy.discrs.ngsolve import NgsSpace logging.basicConfig( level=logging.INFO, format='%(asctime)s %(levelname)s %(name)-40s :: %(message)s') meshsize_domain = 100 meshsize_codomain = 100 mesh = Make1DMesh(meshsize_domain) fes_domain = ngs.L2(mesh, order=2, dirichlet="left|right") domain = NgsSpace(fes_domain) mesh = Make1DMesh(meshsize_codomain) fes_codomain = ngs.H1(mesh, order=2, dirichlet="left|right") codomain = NgsSpace(fes_codomain) rhs = 10 * ngs.x**2 op = Coefficient(domain, codomain=codomain, rhs=rhs, bc_left=1, bc_right=1.1, diffusion=False, reaction=True) N_domain = op.fes_domain.ndof N_codomain = op.fes_codomain.ndof exact_solution_coeff = 1 + ngs.x
from regpy.hilbert import L2, Sobolev from regpy.discrs.ngsolve import NgsSpace logging.basicConfig( level=logging.INFO, format='%(asctime)s %(levelname)s %(name)-40s :: %(message)s') meshsize_domain = 10 meshsize_codomain = 10 mesh = MakeQuadMesh(meshsize_domain) fes_domain = ngs.L2(mesh, order=2) domain = NgsSpace(fes_domain) mesh = MakeQuadMesh(meshsize_codomain) fes_codomain = ngs.H1(mesh, order=3, dirichlet="left|top|right|bottom") codomain = NgsSpace(fes_codomain) rhs = 10 * ngs.sin(ngs.x) * ngs.sin(ngs.y) op = Coefficient(domain, rhs, codomain=codomain, bc_left=0, bc_right=0, bc_bottom=0, bc_top=0, diffusion=False, reaction=True, dim=2) exact_solution_coeff = ngs.x + 1
def __init__(self, domain, g, codomain=None): codomain = codomain or domain self.g = g # self.pts=pts # Define mesh and finite element space # geo=SplineGeometry() # geo.AddCircle((0,0), 1, bc="circle") # ngmesh = geo.GenerateMesh() # ngmesh.Save('ngmesh') # self.mesh=MakeQuadMesh(10) # self.mesh=Mesh(ngmesh) self.fes_domain = domain.fes self.fes_codomain = codomain.fes # Variables for setting of boundary values later # self.ind=[v.point in pts for v in self.mesh.vertices] self.pts = [v.point for v in self.fes_codomain.mesh.vertices] self.ind = [np.linalg.norm(np.array(p)) > 0.95 for p in self.pts] self.pts_bdr = np.array(self.pts)[self.ind] self.fes_in = ngs.H1(self.fes_codomain.mesh, order=1) self.gfu_in = ngs.GridFunction(self.fes_in) # grid functions for later use self.gfu = ngs.GridFunction( self.fes_codomain) # solution, return value of _eval self.gfu_bdr = ngs.GridFunction( self.fes_codomain ) # grid function holding boundary values, g/sigma=du/dn self.gfu_integrator = ngs.GridFunction( self.fes_domain ) # grid function for defining integrator (bilinearform) self.gfu_integrator_codomain = ngs.GridFunction(self.fes_codomain) self.gfu_rhs = ngs.GridFunction( self.fes_codomain ) # grid function for defining right hand side (linearform), f self.gfu_inner_domain = ngs.GridFunction( self.fes_domain ) # grid function for reading in values in derivative self.gfu_inner = ngs.GridFunction( self.fes_codomain ) # grid function for inner computation in derivative and adjoint self.gfu_deriv = ngs.GridFunction( self.fes_codomain) # gridd function return value of derivative self.gfu_toret = ngs.GridFunction( self.fes_domain ) # grid function for returning values in adjoint and derivative self.gfu_dir = ngs.GridFunction( self.fes_domain ) # grid function for solving the dirichlet problem in adjoint self.gfu_error = ngs.GridFunction( self.fes_codomain ) # grid function used in _target to compute the error in forward computation self.gfu_tar = ngs.GridFunction( self.fes_codomain ) # grid function used in _target, holding the arguments self.gfu_adjtoret = ngs.GridFunction(self.fes_domain) self.Number = ngs.NumberSpace(self.fes_codomain.mesh) r, s = self.Number.TnT() u = self.fes_codomain.TrialFunction() # symbolic object v = self.fes_codomain.TestFunction() # symbolic object # Define Bilinearform, will be assembled later self.a = ngs.BilinearForm(self.fes_codomain, symmetric=True) self.a += ngs.SymbolicBFI( ngs.grad(u) * ngs.grad(v) * self.gfu_integrator_codomain) ########new self.a += ngs.SymbolicBFI( u * s + v * r, definedon=self.fes_codomain.mesh.Boundaries("cyc")) self.fes1 = ngs.H1(self.fes_codomain.mesh, order=2, definedon=self.fes_codomain.mesh.Boundaries("cyc")) self.gfu_getbdr = ngs.GridFunction(self.fes1) self.gfu_setbdr = ngs.GridFunction(self.fes_codomain) # Define Linearform, will be assembled later self.f = ngs.LinearForm(self.fes_codomain) self.f += ngs.SymbolicLFI(self.gfu_rhs * v) self.r = self.f.vec.CreateVector() self.b = ngs.LinearForm(self.fes_codomain) self.gfu_b = ngs.GridFunction(self.fes_codomain) self.b += ngs.SymbolicLFI( self.gfu_b * v.Trace(), definedon=self.fes_codomain.mesh.Boundaries("cyc")) self.f_deriv = ngs.LinearForm(self.fes_codomain) self.f_deriv += ngs.SymbolicLFI(self.gfu_rhs * ngs.grad(self.gfu) * ngs.grad(v)) # self.b2=LinearForm(self.fes) # self.b2+=SymbolicLFI(div(v*grad(self.gfu)) super().__init__(domain, codomain)
""" A small script that loads the results of sequential and parallel FEAST using NGSolve. """ import ngsolve as ng if __name__ == '__main__': try: # Load the mesh from file. mesh = ng.Mesh('outputs/mesh.vol') # Create our H1 finite element space. order = 2 dirichlet = 'top|right|bottom|left' X = ng.H1(mesh, order=order, dirichlet=dirichlet, complex=True) # Create an index array for the gridfunctions. idx = list(range(0, 3)) gf_sequential = [] gf_mpi = [] middlename = 'gridfunction' for k in range(len(idx)): # Create two grid functions: One for the sequential solve, and one # for the MPI solve. sequential_name = 'sequential_' + middlename + '_{0:02d}' gf_sequential += [ ng.GridFunction(X, name=sequential_name.format(idx[k]))
from netgen.csg import * geo1 = CSGeometry() geo1.Add(OrthoBrick(Pnt(0, 0, 0), Pnt(1, 1, 1))) m1 = geo1.GenerateMesh(maxh=0.1) mesh = ngs.Mesh(m1) # Next, we make the NGSolve and Bempp function spaces. # # The function ``p1_trace`` will extract the trace space from the ngsovle space and create the matrix ``trace_matrix``, which maps between the dofs (degrees of freedom) in NGSolve and Bempp. # In[4]: from simple_ngbem import * ng_space = ngs.H1(mesh, order=1, complex=True) trace_space, trace_matrix = p1_trace(ng_space) bempp_space = bempp.api.function_space(trace_space.grid, "DP", 0) print("FEM dofs: {0}".format(mesh.nv)) print("BEM dofs: {0}".format(bempp_space.global_dof_count)) # We create the boundary operators that we need. # In[5]: id_op = bempp.api.operators.boundary.sparse.identity(trace_space, bempp_space, bempp_space) mass = bempp.api.operators.boundary.sparse.identity(bempp_space, bempp_space, trace_space)
## Model Parameters battery_capacity = 2 * 1e-3 * 3600 * 1e-8 # A s µm^-2 discharge_current_density = 1 * battery_capacity # A µm^-2 ## Initial values initial_concentration = 1e3 * 1e-18 # mol µm^-3 ## Material Properties diffusivity = 2.66e-5 * 1e8 # µm^2 s^-1 with ngs.TaskManager(): mesh = ngs.Mesh('mesh.vol') V = ngs.H1(mesh, order=1) print(V.ndof) u = V.TrialFunction() v = V.TestFunction() mass = ngs.BilinearForm(V) mass += ngs.SymbolicBFI(u * v) mass.Assemble() a = ngs.BilinearForm(V) a += ngs.SymbolicBFI(diffusivity * grad(u) * grad(v)) a.Assemble() f = ngs.LinearForm(V) f += ngs.SymbolicLFI(discharge_current_density / F * v.Trace(), ngs.BND,
"""Solve complex equation on a square.""" # pylint: disable=no-member from ctypes import CDLL from netgen.geom2d import unit_square import ngsolve as ngs from ngsolve import grad CDLL('libh1amg.so') with ngs.TaskManager(): mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.15)) fes = ngs.H1(mesh, dirichlet=[1, 2, 3], order=1, complex=True) 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) + 1j * u * v) c = ngs.Preconditioner(a, 'h1amg2') # c = ngs.Preconditioner(a, 'direct')
for i in range(0, n_elems + 1): pnt_x = x_min + length * i / n_elems xs.append(pnt_x) pnums.append(m.Add(ngm.MeshPoint(ngm.Pnt(pnt_x, 0, 0)))) for i in range(0, n_elems): m.Add(ngm.Element1D([pnums[i], pnums[i + 1]], index=1)) m.SetMaterial(1, 'material') m.Add(ngm.Element0D(pnums[0], index=1)) m.Add(ngm.Element0D(pnums[n_elems], index=2)) ## NGSolve mesh = ngs.Mesh(m) fes = ngs.H1(mesh, order=1, dirichlet=[1, 2], complex=True) u = fes.TrialFunction() v = fes.TestFunction() ## Potentials ### Potential barrier barrier_w = 2 barrier_h = 1 potential = ngs.CoefficientFunction( ngs.IfPos(x, barrier_h, 0) - ngs.IfPos(x - barrier_w, barrier_h, 0)) ### Square potential # potential = ngs.CoefficientFunction(1/2*x*x-10) ### Zero potential
def charge_flux_prefactor_anode(concentration): """Return prefactor for Butler-Volmer relation in anode params: concentration - Lithium concentration """ # TODO: use power empirical constants here instead of sqrt solubility_difference = ngs.IfPos(solubility_limit_anode - concentration, solubility_limit_anode - concentration, 0) li_factor = sqrt(solubility_difference) * sqrt(concentration) return F * reaction_rate * li_factor mesh = ngs.Mesh('mesh.vol') n_lithium_space = ngs.H1(mesh, order=1) potential_space = ngs.H1(mesh, order=1, dirichlet='anode') V = ngs.FESpace([n_lithium_space, potential_space]) print(V.ndof) u, p = V.TrialFunction() v, q = V.TestFunction() # Coefficient functions cf_diffusivity = ngs.CoefficientFunction([diffusivity[mat] for mat in mesh.GetMaterials()]) cf_conductivity = ngs.CoefficientFunction([conductivity[mat] for mat in mesh.GetMaterials()]) cf_valence = ngs.CoefficientFunction([valence[mat] for mat in mesh.GetMaterials()]) def material_overpotential_cathode(concentr, pot): """Return material overpotential for cathode Li_yMn2O4 particles"""
print(k, V.FreeDofs()[k], len(pds.Dof2Proc(k)) > 0) if ngsolve.mpi_world.rank == 1: hfl = len(hofrees_loc) print('hfl:', hfl) print('set free:', hofrees_loc[6]) print('hofrees_loc:', hofrees_loc) print('hofrees_ex:', hofrees_ex) V.FreeDofs()[10 + 15] = True #for k in hofrees_loc[0:1]: # V.FreeDofs()[k] = True import sys sys.stdout.flush() W = ngsolve.H1(mesh, order=order) gfbf = ngsolve.GridFunction(W) gfbf.vec[:] = 0 if ngsolve.mpi_world.rank == 1: gfbf.vec[10 + 15] = 1 ngsolve.Draw(mesh, name="mesh") ngsolve.Draw(gfbf, mesh, name="bf") dobft = False if dobft: while True: bf_nr = int(0) if ngsolve.mpi_world.rank == 0: bf_nr = int(input('nr ?')) print('got nr', bf_nr)
def setup_rot_elast(mesh, mu=1, lam=0, f_vol=None, multidim=True, reorder=False, diri=".*", order=1, fes_opts=dict(), blf_opts=dict(), lf_opts=dict()): dim = mesh.dim mysum = lambda x: sum(x[1:], x[0]) if dim == 2: to_skew = lambda x: ngs.CoefficientFunction( (0, -x[0], x[0], 0), dims=(2, 2)) else: # to_skew = lambda x : ngs.CoefficientFunction( ( 0 , x[2], -x[1], \ # -x[2], 0 , x[0], \ # x[1], -x[0], 0), dims = (3,3) ) to_skew = lambda x : ngs.CoefficientFunction( ( 0 , -x[2], x[1], \ x[2], 0 , -x[0], \ -x[1], x[0], 0), dims = (3,3) ) if multidim: mdim = dim + ((dim - 1) * dim) // 2 V = ngs.H1(mesh, order=order, dirichlet=diri, **fes_opts, dim=mdim) if reorder: V = ngs.comp.Reorder(V) trial, test = V.TnT() u = ngs.CoefficientFunction(tuple(trial[x] for x in range(dim))) gradu = ngs.CoefficientFunction(tuple( ngs.Grad(trial)[i, j] for i in range(dim) for j in range(dim)), dims=(dim, dim)) divu = mysum([ngs.Grad(trial)[i, i] for i in range(dim)]) w = to_skew([trial[x] for x in range(dim, mdim)]) ut = ngs.CoefficientFunction(tuple(test[x] for x in range(dim))) gradut = ngs.CoefficientFunction(tuple( ngs.Grad(test)[i, j] for i in range(dim) for j in range(dim)), dims=(dim, dim)) divut = mysum([ngs.Grad(test)[i, i] for i in range(dim)]) wt = to_skew([test[x] for x in range(dim, mdim)]) else: Vu = ngs.VectorH1(mesh, order=order, dirichlet=diri, **fes_opts) if reorder == "sep": Vu = ngs.comp.Reorder(Vu) if dim == 3: Vw = Vu else: Vw = ngs.H1(mesh, order=order, dirichlet=diri, **fes_opts) if reorder == "sep": Vw = ngs.comp.Reorder(Vw) V = ngs.FESpace([Vu, Vw]) # print("free pre RO: ", V.FreeDofs()) if reorder is True: V = ngs.comp.Reorder(V) # print("free post RO: ", V.FreeDofs()) (u, w), (ut, wt) = V.TnT() gradu = ngs.Grad(u) divu = mysum([ngs.Grad(u)[i, i] for i in range(dim)]) w = to_skew(w) gradut = ngs.Grad(ut) divut = mysum([ngs.Grad(ut)[i, i] for i in range(dim)]) wt = to_skew(wt) a = ngs.BilinearForm(V, **blf_opts) a += (mu * ngs.InnerProduct(gradu - w, gradut - wt)) * ngs.dx #a += ngs.InnerProduct(w,wt) * ngs.dx #trial, test = V.TnT() #a += 0.1 * ngs.InnerProduct(trial,test) * ngs.dx if lam != 0: a += lam * divu * divut * ngs.dx lf = ngs.LinearForm(V) lf += f_vol * ut * ngs.dx return V, a, lf
geo.Append(['line', p1, p2], leftdomain=1, rightdomain=0, bc='dirichlet') geo.Append(['line', p2, p3], leftdomain=1, rightdomain=0, bc='dirichlet') geo.Append(['line', p3, p4], leftdomain=1, rightdomain=0, bc='dirichlet') geo.Append(['line', p4, p1], leftdomain=1, rightdomain=0) geo.AddRectangle((0.2, 0.6), (0.8, 0.7), leftdomain=2, rightdomain=1) return geo with ngs.TaskManager(): square_conductivity = square_conductivity_geo() mesh = ngs.Mesh(square_conductivity.GenerateMesh(maxh=0.05)) fes = ngs.H1(mesh, dirichlet='dirichlet', order=1) u = fes.TrialFunction() v = fes.TestFunction() # rhs f = ngs.LinearForm(fes) f += ngs.SymbolicLFI(v) # lhs lam = ngs.DomainConstantCF([1, 1000]) a = ngs.BilinearForm(fes, symmetric=True) a += ngs.SymbolicBFI(lam * grad(u) * grad(v)) c = ngs.Preconditioner(a, 'h1amg', flags={'test': True, 'levels': 10}) gfu = ngs.GridFunction(fes)
def __init__(self, domain, g, codomain=None): codomain = codomain or domain self.g = g self.fes_domain = domain.fes self.fes_codomain = codomain.fes self.fes_in = ngs.H1(self.fes_codomain.mesh, order=1) self.gfu_in = ngs.GridFunction(self.fes_in) # grid functions for later use self.gfu = ngs.GridFunction( self.fes_codomain) # solution, return value of _eval # self.gfu_bdr=ngs.GridFunction(self.fes_codomain) #grid function holding boundary values, g/sigma=du/dn self.gfu_bilinearform = ngs.GridFunction( self.fes_domain ) # grid function for defining integrator (bilinearform) self.gfu_bilinearform_codomain = ngs.GridFunction( self.fes_codomain ) # grid function for defining integrator of bilinearform self.gfu_linearform_domain = ngs.GridFunction( self.fes_codomain) # grid function for defining linearform self.gfu_linearform_codomain = ngs.GridFunction(self.fes_domain) self.gfu_deriv_toret = ngs.GridFunction( self.fes_codomain) # grid function: return value of derivative self.gfu_adj = ngs.GridFunction( self.fes_domain) # grid function for inner computation in adjoint self.gfu_adj_toret = ngs.GridFunction( self.fes_domain) # grid function: return value of adjoint self.gfu_b = ngs.GridFunction( self.fes_codomain) # grid function for defining the boundary term u = self.fes_codomain.TrialFunction() # symbolic object v = self.fes_codomain.TestFunction() # symbolic object # Define Bilinearform, will be assembled later self.a = ngs.BilinearForm(self.fes_codomain, symmetric=True) self.a += ngs.SymbolicBFI(-ngs.grad(u) * ngs.grad(v) + u * v * self.gfu_bilinearform_codomain) # Interaction with Trace self.fes_bdr = ngs.H1( self.fes_codomain.mesh, order=self.fes_codomain.globalorder, definedon=self.fes_codomain.mesh.Boundaries("cyc")) self.gfu_getbdr = ngs.GridFunction(self.fes_bdr) self.gfu_setbdr = ngs.GridFunction(self.fes_codomain) # Boundary term self.b = ngs.LinearForm(self.fes_codomain) self.b += ngs.SymbolicLFI( -self.gfu_b * v.Trace(), definedon=self.fes_codomain.mesh.Boundaries("cyc")) # Linearform (only appears in derivative) self.f_deriv = ngs.LinearForm(self.fes_codomain) self.f_deriv += ngs.SymbolicLFI(-self.gfu_linearform_codomain * self.gfu * v) super().__init__(domain, codomain)
for n in names: p = pv.Plotter() p.add_mesh(mesh.warp_by_scalar(n), scalars=n) panels[n] = p.show(use_panel=True) return panels noiselevel = 0.01 geo = SplineGeometry() geo.AddRectangle((0.4, 0.45), (0.6, 0.55), leftdomain=0, rightdomain=1) geo.AddRectangle((0, 0), (1, 1), bcs=["bottom", "right", "top", "left"], leftdomain=1) domain = NgsSpace(ngs.H1(ngs.Mesh(geo.GenerateMesh(maxh=0.4)), order=1)) codomain = NgsSpace( ngs.H1(ngs.Mesh(geo.GenerateMesh(maxh=0.1)), order=1, dirichlet="left|top|right|bottom")) cfu_exact_solution = 1 + ngs.x exact_solution = domain.from_ngs(cfu_exact_solution) op = Coefficient(domain=domain, codomain=codomain, rhs=10 * ngs.sin(ngs.x) * ngs.sin(ngs.y), bc_left=0, bc_right=0, bc_bottom=0, bc_top=0,
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()
""" Simulate the time-independent Schrödinger Equation""" from scipy.constants import m_e, hbar import ngsolve as ngs from ngsolve import grad from netgen.geom2d import unit_square from random import random mesh = ngs.Mesh(unit_square.GenerateMesh(maxh=0.05)) fes = ngs.H1(mesh, order=2, dirichlet=[1,2,3,4], complex=True) u = fes.TrialFunction() v = fes.TestFunction() a = ngs.BilinearForm(fes) a += ngs.SymbolicBFI(hbar / 2 / m_e * grad(u) * grad(v)) a.Assemble() m = ngs.BilinearForm(fes) m += ngs.SymbolicBFI(u * v) m.Assemble() gf_psi = ngs.GridFunction(fes) freedofs = fes.FreeDofs() for i in range(len(gf_psi.vec)): gf_psi.vec[i] = random() if freedofs[i] else 0
"""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)
import regpy.stoprules as rules from regpy.operators.ngsolve import ReactionBoundary from regpy.solvers import HilbertSpaceSetting from regpy.solvers.landweber import Landweber from regpy.hilbert import L2, SobolevBoundary from regpy.discrs.ngsolve import NgsSpace logging.basicConfig( level=logging.INFO, format='%(asctime)s %(levelname)s %(name)-40s :: %(message)s') geo = SplineGeometry() geo.AddCircle((0, 0), r=1, bc="cyc", maxh=0.2) mesh = ngs.Mesh(geo.GenerateMesh()) fes_domain = ngs.H1(mesh, order=2) domain = NgsSpace(fes_domain) fes_codomain = ngs.H1(mesh, order=2) codomain = NgsSpace(fes_codomain) g = ngs.x**2 * ngs.y op = ReactionBoundary(domain, g, codomain=codomain) exact_solution_coeff = ngs.sin(ngs.y) + 2 gfu_exact_solution = ngs.GridFunction(op.fes_domain) gfu_exact_solution.Set(exact_solution_coeff) exact_solution = gfu_exact_solution.vec.FV().NumPy() exact_data = op(exact_solution) fes_noise = ngs.L2(fes_codomain.mesh, order=1)