ngsolve 6.2.2501.post21.dev1__cp312-cp312-macosx_10_15_universal2.whl → 6.2.2501.post37.dev1__cp312-cp312-macosx_10_15_universal2.whl

ngsolve/demos/intro/poisson.ipynb

@@ -1,170 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Poisson Equation\n",
-    "==="
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Import Netgen/NGSolve Python modules:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from ngsolve import *\n",
-    "from netgen.geom2d import unit_square\n",
-    "import netgen.gui\n",
-    "%gui tk"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The unit_square is a predefined domain, use Netgen to generate a mesh:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mesh = Mesh(unit_square.GenerateMesh(maxh=0.2))\n",
-    "Draw (mesh)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Define a finite element space on that mesh. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fes = H1(mesh, order=3, dirichlet=\"left|right|bottom|top\")\n",
-    "print (\"ndof =\", fes.ndof)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Define linear and bilinear-forms. Forms are expressed in terms of trial and test-functions:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "u = fes.TrialFunction()\n",
-    "v = fes.TestFunction()\n",
-    "\n",
-    "f = LinearForm(fes)\n",
-    "f += 32 * (y*(1-y)+x*(1-x)) * v * dx\n",
-    "\n",
-    "a = BilinearForm(fes)\n",
-    "a += grad(u)*grad(v)*dx\n",
-    "\n",
-    "a.Assemble()\n",
-    "f.Assemble()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Solve the problem:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gfu = GridFunction(fes)\n",
-    "gfu.vec.data = a.mat.Inverse(fes.FreeDofs()) * f.vec"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Plot the solution:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Draw (gfu)\n",
-    "Draw (-grad(gfu), mesh, \"Flux\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "exact = 16*x*(1-x)*y*(1-y)\n",
-    "print (\"L2-error:\", sqrt (Integrate ( (gfu-exact)*(gfu-exact), mesh)))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

ngsolve/demos/intro/poisson.py

@@ -1,41 +0,0 @@
-# solve the Poisson equation -Delta u = f
-# with Dirichlet boundary condition u = 0
-
-from ngsolve import *
-# from netgen.geom2d import unit_square
-
-ngsglobals.msg_level = 1
-
-# generate a triangular mesh of mesh-size 0.2
-mesh = Mesh(unit_square.GenerateMesh(maxh=0.2))
-
-# H1-conforming finite element space
-fes = H1(mesh, order=3, dirichlet=[1,2,3,4])
-
-# define trial- and test-functions
-u = fes.TrialFunction()
-v = fes.TestFunction()
-
-# the right hand side
-f = LinearForm(fes)
-f += 32 * (y*(1-y)+x*(1-x)) * v * dx
-
-# the bilinear-form 
-a = BilinearForm(fes, symmetric=True)
-a += grad(u)*grad(v)*dx
-
-a.Assemble()
-f.Assemble()
-
-# the solution field 
-gfu = GridFunction(fes)
-gfu.vec.data = a.mat.Inverse(fes.FreeDofs(), inverse="sparsecholesky") * f.vec
-# print (u.vec)
-
-
-# plot the solution (netgen-gui only)
-Draw (gfu)
-Draw (-grad(gfu), mesh, "Flux")
-
-exact = 16*x*(1-x)*y*(1-y)
-print ("L2-error:", sqrt (Integrate ( (gfu-exact)*(gfu-exact), mesh)))

ngsolve/demos/mpi/mpi_cmagnet.py

@@ -1,87 +0,0 @@
-from netgen.csg import *
-import netgen.meshing
-
-from ngsolve import *
-
-from mpi4py.MPI import COMM_WORLD as comm
-rank = comm.rank
-np = comm.size
-
-do_vtk = False
-
-def MakeGeometry():
-    geometry = CSGeometry()
-    box = OrthoBrick(Pnt(-1,-1,-1),Pnt(2,1,2)).bc("outer")
-
-    core = OrthoBrick(Pnt(0,-0.05,0),Pnt(0.8,0.05,1))- \
-           OrthoBrick(Pnt(0.1,-1,0.1),Pnt(0.7,1,0.9))- \
-           OrthoBrick(Pnt(0.5,-1,0.4),Pnt(1,1,0.6)).maxh(0.2).mat("core")
-    
-    coil = (Cylinder(Pnt(0.05,0,0), Pnt(0.05,0,1), 0.3) - \
-            Cylinder(Pnt(0.05,0,0), Pnt(0.05,0,1), 0.15)) * \
-            OrthoBrick (Pnt(-1,-1,0.3),Pnt(1,1,0.7)).maxh(0.2).mat("coil")
-    
-    geometry.Add ((box-core-coil).mat("air"))
-    geometry.Add (core)
-    geometry.Add (coil)
-    return geometry
-
-# For curving, we need the geometry. We have to
-# generate it everywhere and then set it.
-# It is not distributed automatically.
-geom = MakeGeometry()
-if rank==0:
-    # master proc generates and immediately distributes
-    ngmesh = geom.GenerateMesh(maxh=0.5)
-    ngmesh.Distribute(comm)
-else:
-    # worker procs receive mesh
-    ngmesh = netgen.meshing.Mesh.Receive(comm)
-    # and then manually set the geometry
-    ngmesh.SetGeometry(geom)
-mesh = Mesh(ngmesh)
-
-# now we can curve!
-mesh.Curve(5)
-
-ngsglobals.msg_level = 5
-
-fes = HCurl(mesh, order=4, dirichlet="outer", nograds = True)
-
-
-u = fes.TrialFunction()
-v = fes.TestFunction()
-
-mur = { "core" : 1000, "coil" : 1, "air" : 1 }
-mu0 = 1.257e-6
-
-nu_coef = [ 1/(mu0*mur[mat]) for mat in mesh.GetMaterials() ]
-
-nu = CoefficientFunction(nu_coef)
-a = BilinearForm(fes, symmetric=True)
-a += SymbolicBFI(nu*curl(u)*curl(v) + 1e-6*nu*u*v)
-
-c = Preconditioner(a, type="bddc", flags={"inverse":"masterinverse"})
-#c = Preconditioner(a, type="bddc", inverse = "mumps")
-
-f = LinearForm(fes)
-f += SymbolicLFI(CoefficientFunction((y,0.05-x,0)) * v, definedon=mesh.Materials("coil"))
-
-u = GridFunction(fes)
-
-
-a.Assemble()
-f.Assemble()
-solver = CGSolver(mat=a.mat, pre=c.mat)
-u.vec.data = solver * f.vec
-
-if do_vtk:
-    import os
-    output_path = os.path.dirname(os.path.realpath(__file__)) + "/cmagnet_output"
-    if rank==0 and not os.path.exists(output_path):
-        os.mkdir(output_path)
-    comm.Barrier() #wait until master has created the directory!!
-    vtk = VTKOutput(ma=mesh, coefs=[u.Deriv()], names=["sol"], filename=output_path+"/vtkout", subdivision=2)
-    vtk.Do()
-
-#Draw (u.Deriv(), mesh, "B-field", draw_surf=False)

ngsolve/demos/mpi/mpi_navierstokes.py

@@ -1,117 +0,0 @@
-import netgen.meshing
-from netgen.geom2d import SplineGeometry
-
-
-from ngsolve import *
-
-SetNumThreads(1)  
-
-from mpi4py.MPI import COMM_WORLD as comm
-rank = comm.rank
-np = comm.size
-
-do_vtk = False
-
-# viscosity
-nu = 0.001
-
-# timestepping parameters
-tau = 0.001
-tend = 3
-
-# mesh = Mesh("cylinder.vol")
-geo = SplineGeometry()
-geo.AddRectangle( (0, 0), (2, 0.41), bcs = ("wall", "outlet", "wall", "inlet"))
-geo.AddCircle ( (0.2, 0.2), r=0.05, leftdomain=0, rightdomain=1, bc="cyl")
-if rank==0:
-    ngmesh = geo.GenerateMesh(maxh=0.08)
-    ngmesh.Distribute(comm)
-else:
-    ngmesh = netgen.meshing.Mesh.Receive(comm)
-    ngmesh.SetGeometry(geo)
-    
-mesh = Mesh(ngmesh)
-
-#does not work with mpi yet...
-#mesh.Curve(3)
-
-V = H1(mesh,order=3, dirichlet="wall|cyl|inlet")
-Q = H1(mesh,order=2)
-
-X = FESpace([V,V,Q])
-
-ux,uy,p = X.TrialFunction()
-vx,vy,q = X.TestFunction()
-
-div_u = grad(ux)[0]+grad(uy)[1]
-div_v = grad(vx)[0]+grad(vy)[1]
-
-stokes = nu*grad(ux)*grad(vx)+nu*grad(uy)*grad(vy)+div_u*q+div_v*p - 1e-10*p*q
-a = BilinearForm(X)
-a += SymbolicBFI(stokes)
-a.Assemble()
-
-# nothing here ...
-f = LinearForm(X)   
-f.Assemble()
-
-# gridfunction for the solution
-gfu = GridFunction(X)
-
-# parabolic inflow at bc=1:
-uin = 1.5*4*y*(0.41-y)/(0.41*0.41)
-gfu.components[0].Set(uin, definedon=mesh.Boundaries("inlet"))
-
-velocity = CoefficientFunction(gfu.components[0:2])
-
-
-# solve Stokes problem for initial conditions:
-#inv_stokes = a.mat.Inverse(X.FreeDofs(), inverse="mumps")
-inv_stokes = a.mat.Inverse(X.FreeDofs(), inverse="masterinverse")
-res = f.vec.CreateVector()
-res.data = f.vec - a.mat*gfu.vec
-gfu.vec.data += inv_stokes * res
-
-# matrix for implicit Euler 
-mstar = BilinearForm(X)
-mstar += SymbolicBFI(ux*vx+uy*vy + tau*stokes)
-mstar.Assemble()
-
-# inv = mstar.mat.Inverse(X.FreeDofs(), inverse="masterinverse")
-inv = mstar.mat.Inverse(X.FreeDofs(), inverse="masterinverse")
-
-# the non-linear term 
-conv = BilinearForm(X, nonassemble = True)
-conv += SymbolicBFI( CoefficientFunction( (ux,uy) ) * (grad(ux)*vx+grad(uy)*vy) )
-
-t = 0
-vtk_interval = int(0.05/tau);
-
-import os
-#output_path = os.path.dirname(os.path.realpath(__file__)) + "/navierstokes_output"
-output_path = os.path.dirname(os.path.realpath(__file__)) + "/navierstokes_output"
-if rank==0 and not os.path.exists(output_path):
-    os.mkdir(output_path)
-comm.Barrier() #wait until master has created the directory!!
-
-if do_vtk:
-    vtk = VTKOutput(ma=mesh,coefs=[velocity],names=["u"],filename=output_path+"/vtkout",subdivision=2)
-    vtk.Do()
-
-count = 1;
-# implicit Euler/explicit Euler splitting method:
-with TaskManager():
-    while t < tend:
-        if rank==0:
-            print ("t=", t)
-            
-        conv.Apply (gfu.vec, res)
-        res.data += a.mat*gfu.vec
-        gfu.vec.data -= tau * inv * res
-
-        if count%vtk_interval==0 and do_vtk:
-            vtk.Do(time = t)
-        count = count+1;
-
-        t = t + tau
-        comm.Barrier()

ngsolve/demos/mpi/mpi_poisson.py

@@ -1,89 +0,0 @@
-# Call with: 
-# mpirun -np 5 ngspy mpi_poisson.py
-
-# Solves -laplace(u)=f on [0,1]^3
-
-# netgen-imports
-#from netgen.geom2d import unit_square
-from netgen.csg import unit_cube
-import netgen.meshing
-
-# ngsolve-imports
-from ngsolve import *
-
-# initialize MPI
-from mpi4py.MPI import COMM_WORLD as comm
-rank = comm.rank
-np = comm.size
-
-do_vtk = False
-
-print("Hello from rank "+str(rank)+" of "+str(np))
-
-if rank==0:
-    # master-proc generates mesh
-    mesh = unit_cube.GenerateMesh(maxh=0.3)
-    # and saves it to file
-    mesh.Save("some_mesh.vol")
-
-# wait for master to be done meshing
-comm.Barrier()
-
-# now load mesh from file
-ngmesh = netgen.meshing.Mesh(dim=3, comm=comm)
-ngmesh.Load("some_mesh.vol")
-
-#refine once?
-# ngmesh.Refine()
-
-mesh = Mesh(ngmesh)
-
-# build H1-FESpace as usual
-V = H1(mesh, order=3, dirichlet=[1,2,3,4])
-u = V.TrialFunction()
-v = V.TestFunction()
-
-print("rank "+str(rank)+" has "+str(V.ndof)+" of "+str(V.ndofglobal)+" dofs!")
-
-# RHS does not change either!
-f = LinearForm (V)
-f += SymbolicLFI(32 * (y*(1-y)+x*(1-x)) * v)
-f.Assemble()
-
-# neither does the BLF!
-a = BilinearForm (V, symmetric=False)
-a += SymbolicBFI(grad(u)*grad(v))
-
-# Some possible preconditioners: 
-c = Preconditioner(a, type="direct", inverse = "masterinverse") # direct solve with mumps
-#c = Preconditioner(a, type="bddc", inverse = "mumps")   # BBDC + mumps for coarse inverse
-#c = Preconditioner(a, type="hypre")                             # BoomerAMG (use only for order 1)
-#c = Preconditioner(a, type="bddc", usehypre = True)     # BDDC + BoomerAMG for coarse matrix
-
-a.Assemble()
-
-# solve the equation
-u = GridFunction (V)
-u.vec.data = CGSolver(a.mat, c.mat) * f.vec  # use CG-solver with preconditioner c
-# u.vec.data = a.mat.Inverse(V.FreeDofs(), inverse="mumps") * f.vec  # use MUMPS parallel inverse
-# u.vec.data = a.mat.Inverse(V.FreeDofs(), inverse="masterinverse") * f.vec  # use masterinverse (master proc does all the work!)
-
-
-#exact solution
-exact = 16*x*(1-x)*y*(1-y)
-
-# error 
-error = Integrate ( (u-exact)*(u-exact) , mesh)
-if rank==0:
-    print("L2-error", error )
-
-if do_vtk:
-    # do VTK-output
-    import os
-    output_path = os.path.dirname(os.path.realpath(__file__)) + "/poisson_output"
-    if rank==0 and not os.path.exists(output_path):
-        os.mkdir(output_path)
-    comm.Barrier() #wait until master has created the directory!!
-
-    vtk = VTKOutput(mesh, coefs=[u], names=["sol"], filename=output_path+"/vtkout", subdivision=2)
-    vtk.Do()

ngsolve/demos/mpi/mpi_timeDG.py

@@ -1,82 +0,0 @@
-# Call with:
-# mpirun -np 5 ngspy mpi_timeDG.py
-
-# Then make movie with:
-# python3 make_timeDG_movie.py
-# (this only works if you have paraview+python3 configured properly)
-
-# circular convection; time-DG with skeleton-formulation
-
-
-from netgen.geom2d import unit_square
-import netgen.meshing
-
-
-from ngsolve import *
-
-SetNumThreads(1)
-
-from mpi4py.MPI import COMM_WORLD as comm
-rank = comm.rank
-np = comm.size
-
-do_vtk = False
-
-if rank==0:
-    ngmesh = unit_square.GenerateMesh(maxh=0.05)
-    ngmesh.Distribute(comm)
-else:
-    ngmesh = netgen.meshing.Mesh.Receive(comm)
-mesh = Mesh(ngmesh)
-
-# build L2-FESpace
-fes = L2(mesh, order=4)
-
-# Trial- and Test-functions
-u = fes.TrialFunction()
-v = fes.TestFunction()
-
-# RHS
-b = CoefficientFunction( (y-0.5,0.5-x) )
-bn = b*specialcf.normal(2)
-
-# Skeleton DG-formulation
-a = BilinearForm(fes)
-a += SymbolicBFI (-u * b*grad(v))
-a += SymbolicBFI ( bn*IfPos(bn, u, u.Other()) * (v-v.Other()), VOL, skeleton=True)
-a += SymbolicBFI ( bn*IfPos(bn, u, 0) * v, BND, skeleton=True)
-
-u = GridFunction(fes)
-u.Set(exp (-40 * ( (x-0.7)*(x-0.7) + (y-0.7)*(y-0.7) )))
-
-w = u.vec.CreateVector()
-
-t = 0
-tau = 5e-4
-tend = 2
-count = 0
-
-vtk_interval = int(0.02/tau);
-
-if do_vtk:
-    import os
-    output_path = os.path.dirname(os.path.realpath(__file__)) + "/timeDG_output"
-    if rank==0 and not os.path.exists(output_path):
-        os.mkdir(output_path)
-    comm.Barrier() #wait until master has created the directory!!
-    vtk = VTKOutput(ma=mesh,coefs=[u],names=["sol"],filename=output_path+"/vtkout",subdivision=2)
-
-with TaskManager():
-    while t < tend:
-        if rank==0:
-            print("t = ", t)
-        a.Apply (u.vec, w)
-        fes.SolveM (rho=CoefficientFunction(1), vec=w)
-        u.vec.data -= tau * w
-        t += tau
-
-        if count%vtk_interval==0 and do_vtk:
-            vtk.Do(time=t)
-        count = count+1;
-
-        comm.Barrier()

ngsolve/directsolvers.pyi

@@ -1,15 +0,0 @@
-from __future__ import annotations
-from ngsolve.comp import BilinearForm
-import ngsolve.la
-from ngsolve.la import BaseMatrix
-from ngsolve.la import BaseVector
-import pyngcore.pyngcore
-from pyngcore.pyngcore import BitArray
-__all__ = ['BaseMatrix', 'BaseVector', 'BilinearForm', 'BitArray', 'SuperLU']
-class SuperLU(ngsolve.la.BaseMatrix):
-    def Mult(self, x: ngsolve.la.BaseVector, y: ngsolve.la.BaseVector):
-        ...
-    def Update(self):
-        ...
-    def __init__(self, a, freedofs: pyngcore.pyngcore.BitArray = None):
-        ...

ngsolve/eigenvalues.pyi

@@ -1,30 +0,0 @@
-from __future__ import annotations
-from math import sqrt
-from ngsolve.bla import Matrix
-from ngsolve.bla import Norm
-from ngsolve.bla import Vector
-from ngsolve.la import IdentityMatrix
-from ngsolve.la import InnerProduct
-from ngsolve.la import MultiVector
-from ngsolve.la import Projector
-__all__ = ['Arnoldi', 'IdentityMatrix', 'InnerProduct', 'LOBPCG', 'Matrix', 'MultiVector', 'Norm', 'Orthogonalize', 'PINVIT', 'PINVIT1', 'Projector', 'SOAR', 'TOAR', 'Vector', 'sqrt']
-def Arnoldi(mat, tol = 1e-10, maxiter = 200):
-    ...
-def LOBPCG(mata, matm, pre, num = 1, maxit = 20, initial = None, printrates = True, largest = False):
-    """
-    Knyazev's cg-like extension of PINVIT
-    """
-def Orthogonalize(vecs, mat):
-    ...
-def PINVIT(mata, matm, pre, num = 1, maxit = 20, printrates = True, GramSchmidt = True):
-    """
-    preconditioned inverse iteration
-    """
-def PINVIT1(mata, matm, pre, num = 1, maxit = 20, printrates = True, GramSchmidt = False):
-    """
-    preconditioned inverse iteration
-    """
-def SOAR(A, B, maxiter = 200):
-    ...
-def TOAR(A, B, maxiter = 200):
-    ...