ngsolve 6.2.2506.post74.dev0__cp314-cp314-macosx_10_15_universal2.whl

ngsolve/TensorProductTools.py

@@ -0,0 +1,210 @@
+from netgen.meshing import *
+from netgen.csg import *
+#from ngsolve import *
+from ngsolve.comp import TensorProductFESpace, Transfer2StdMesh, SymbolicTPBFI, ProlongateCoefficientFunction, TensorProductIntegrate
+import netgen.meshing as ngmeshing
+from netgen.geom2d import SplineGeometry
+import math
+
+
+
+def AddEdgeEls (p1, dx, facenr, n, pids,mesh):
+    for i in range(n):
+        base = p1 + i*dx
+        pnum = [base, base+dx]
+        elpids = [pids[p] for p in pnum]
+        mesh.Add (Element1D(elpids,index=1))
+
+def SegMesh(n,x0,x1,periodic=False):
+    mesh = Mesh(dim=1)
+    pids = []
+    for i in range(n+1):
+        pids.append (mesh.Add (MeshPoint(Pnt(x0+(x1-x0)*i/n, 0, 0))))
+    AddEdgeEls(0,1,1,n,pids,mesh)
+    mesh.Add (Element0D( pids[0], index=1))
+    mesh.Add (Element0D( pids[n], index=2))
+    mesh.SetBCName(0,"left")
+    mesh.SetBCName(1,"right")
+    if periodic == True:
+        mesh.AddPointIdentification(pids[0],pids[n],1,2)
+    return mesh
+
+# create a hexagonal mesh with corner points on the unit circle
+def MakeHexagonalMesh2D(maxh=0.1):
+    geo = SplineGeometry()
+    pnums = [ geo.AddPoint(math.cos(phi),math.sin(phi)) for phi in [xx*math.pi/3 for xx in range(6)] ]
+    l1 = geo.Append(["line", 0, 1], leftdomain=1, rightdomain=0, bc="upperRight")
+    geo.Append(["line", 4, 3], leftdomain=0, rightdomain=1, bc="lowerLeft", copy = l1)
+    l2 = geo.Append(["line", 1, 2], leftdomain=1, rightdomain=0, bc="upperCenter")
+    geo.Append(["line", 5, 4], leftdomain=0, rightdomain=1, bc="lowerCenter", copy = l2)
+    l3 = geo.Append(["line", 2, 3], leftdomain=1, rightdomain=0, bc="upperLeft")
+    geo.Append(["line", 0, 5], leftdomain=0, rightdomain=1, bc="lowerRight", copy = l3)
+    return geo.GenerateMesh(maxh=maxh)
+
+def MakeTensorProductMesh(mesh1,mesh2):
+    if mesh1.dim + mesh2.dim >3:
+        print('MakeMesh only possible if dim<=3!!')
+        return
+    if mesh1.dim + mesh2.dim == 3:
+        tpmesh = MakeMesh3D(mesh1,mesh2)
+    if mesh1.dim + mesh2.dim == 2:
+        tpmesh = MakeMesh2D(mesh1,mesh2)
+    AddSurfElements(tpmesh,mesh1,mesh2)
+    return tpmesh
+
+def AddSurfElements(tpmesh,mesh1,mesh2):
+    if mesh1.dim + mesh2.dim == 3:
+        tpmesh = AddSurfElements2D(tpmesh,mesh1,mesh2)
+    if mesh1.dim + mesh2.dim == 2:
+        tpmesh = AddSurfElements1D(tpmesh,mesh1,mesh2)
+    return tpmesh
+
+    
+def MakeMesh2D(mesh1,mesh2):
+    tpmesh = ngmeshing.Mesh(dim = mesh1.dim + mesh2.dim)
+    ngm1 = mesh1.ngmesh
+    ngm2 = mesh2.ngmesh
+
+    els1 = ngm1.Elements1D()
+    els2 = ngm2.Elements1D()
+    vert1 = ngm1.Points()
+    vert2 = ngm2.Points()
+    pids = []
+    for i in range(len(vert1)):
+        for j in range(len(vert2)):
+            pids.append(tpmesh.Add(MeshPoint(Pnt(vert1[ngmeshing.PointId(i+1)].p[0],vert2[ngmeshing.PointId(j+1)].p[0],0     ))))
+    tpmesh.Add (FaceDescriptor(surfnr=1,domin=1,bc=1))
+    for elx in els1:
+        for ely in els2:
+            pnum = [(elx.vertices[1].nr-1) * len(vert2) + ely.vertices[1].nr-1,
+                    (elx.vertices[0].nr-1) * len(vert2) + ely.vertices[1].nr-1,
+                    (elx.vertices[0].nr-1) * len(vert2) + ely.vertices[0].nr-1,
+                    (elx.vertices[1].nr-1) * len(vert2) + ely.vertices[0].nr-1]
+                    
+            elpids = [pids[p] for p in pnum]
+            tpmesh.Add(Element2D(1,elpids))
+    return tpmesh
+
+def MakeMesh3D(mesh1,mesh2):
+    tpmesh = ngmeshing.Mesh(dim = mesh1.dim + mesh2.dim)
+    ngm1 = mesh1.ngmesh
+    ngm2 = mesh2.ngmesh
+    if mesh1.dim==2:
+        els1 = ngm1.Elements2D()
+        els2 = ngm2.Elements1D()
+        vert1 = ngm1.Points()
+        vert2 = ngm2.Points()
+        pids = []
+        for i in range(len(vert1)):
+            for j in range(len(vert2)):
+                pids.append(tpmesh.Add(MeshPoint(Pnt(vert1[ngmeshing.PointId(i+1)].p[0],vert1[ngmeshing.PointId(i+1)].p[1],vert2[ngmeshing.PointId(j+1)].p[0]))))
+        for elx in els1:
+            for ely in els2:
+                pnum = []
+                for j in reversed(ely.vertices):
+                    for i in elx.vertices:
+                        pnum.append((i.nr-1) * len(vert2) + j.nr-1)
+                elpids = [pids[p] for p in pnum]
+                tpmesh.Add( Element3D(1,elpids) )
+        return tpmesh
+    else:
+        els1 = ngm1.Elements1D()
+        els2 = ngm2.Elements2D()
+        vert1 = ngm1.Points()
+        vert2 = ngm2.Points()
+        pids = []
+        for i in range(len(vert1)):
+            for j in range(len(vert2)):
+                pids.append(tpmesh.Add(MeshPoint(Pnt(vert1[ngmeshing.PointId(i+1)].p[0],vert2[ngmeshing.PointId(j+1)].p[0],vert2[ngmeshing.PointId(j+1)].p[1]))))
+        for elx in els1:
+            for ely in els2:
+                pnum = []
+                for i in reversed(elx.vertices):
+                    for j in (ely.vertices):
+                        pnum.append((i.nr-1) * len(vert2) + j.nr-1)
+                elpids = [pids[p] for p in pnum]
+                tpmesh.Add( Element3D(1,elpids) )
+        return tpmesh
+
+def AddSurfElements1D(tpmesh,mesh1,mesh2):
+    ngm1 = mesh1.ngmesh;
+    ngm2 = mesh2.ngmesh;
+    els1 = ngm1.Elements1D()
+    els2 = ngm2.Elements1D()
+    for ely in els2:
+        elpids = ely.vertices
+        elpids1=[]
+        for i in elpids:
+            elpids1.append(PointId((i.nr-1)+(len(ngm1.Points()) -1 )*(len(ngm2.Points())) + 1 ))
+        tpmesh.Add(Element1D(elpids))
+        tpmesh.Add(Element1D(elpids1))
+    for elx in els1:
+        elpids = elx.vertices
+        elpids1=[]
+        elpids2=[]
+        for i in elpids:
+            elpids1.append(PointId( (i.nr-1)*(len(ngm2.Points()))+1) )
+            elpids2.append(PointId( (i.nr-1)*(len(ngm2.Points()))+(len(ngm2.Points()))) )
+        tpmesh.Add(Element1D(elpids1))
+        tpmesh.Add(Element1D(elpids2))       
+
+def AddSurfElements2D(tpmesh,mesh1,mesh2):
+    ngm1 = mesh1.ngmesh;
+    ngm2 = mesh2.ngmesh;
+    if mesh1.dim==2:
+        els1 = ngm1.Elements2D()
+        els2 = ngm2.Elements1D()
+        tpmesh.Add (FaceDescriptor(surfnr=1,domin=1,bc=1))
+        for elx in els1:
+            vert_loc = elx.vertices
+            vert_glob = []
+            for vx in vert_loc:
+                vert_glob.append(PointId((vx.nr-1)*len(ngm2.Points())+len(ngm2.Points())))
+            tpmesh.Add(Element2D(1,vert_glob))
+        for elx in els1:
+            vert_loc = elx.vertices
+            vert_glob = []
+            for vx in vert_loc:
+                vert_glob = [PointId((vx.nr-1)*len(ngm2.Points())+1)] + vert_glob
+            tpmesh.Add(Element2D(1,vert_glob))
+        els1 = ngm1.Elements1D()
+        for elx in els1:
+            for ely in els2:
+                vert_glob=[]
+#            for vy in ely.vertices:
+#                for vx in elx.vertices:
+                vx = elx.vertices
+                vy = ely.vertices
+                vert_glob = [PointId((vx[1].nr-1)*len(ngm2.Points())+vy[0].nr),
+                            PointId((vx[1].nr-1)*len(ngm2.Points())+vy[1].nr),
+                            PointId((vx[0].nr-1)*len(ngm2.Points())+vy[1].nr),
+                            PointId((vx[0].nr-1)*len(ngm2.Points())+vy[0].nr)]
+                tpmesh.Add(Element2D(1,vert_glob))
+    else:
+        els1 = ngm1.Elements1D()
+        els2 = ngm2.Elements2D()
+        tpmesh.Add (FaceDescriptor(surfnr=1,domin=1,bc=1))
+        for ely in els2:
+            vert_loc = ely.vertices
+            vert_glob = []
+            for vy in vert_loc:
+                vert_glob.append(PointId((vy.nr)+(len(ngm1.Points())-1)*(len(ngm2.Points()))))
+            tpmesh.Add(Element2D(1,vert_glob))
+        for ely in els2:
+            vert_loc = ely.vertices
+            vert_glob = []
+            for vy in reversed(vert_loc):
+                vert_glob.append(PointId( vy.nr))
+            tpmesh.Add(Element2D(1,vert_glob))
+        els2 = ngm2.Elements1D()
+        for elx in els1:
+            for ely in els2:
+                vert_glob=[]
+                vx = elx.vertices
+                vy = ely.vertices
+                vert_glob = [PointId((vx[0].nr-1)*len(ngm2.Points())+vy[0].nr),
+                             PointId((vx[0].nr-1)*len(ngm2.Points())+vy[1].nr),
+                             PointId((vx[1].nr-1)*len(ngm2.Points())+vy[1].nr),
+                             PointId((vx[1].nr-1)*len(ngm2.Points())+vy[0].nr)]
+                tpmesh.Add(Element2D(1,vert_glob))
+    return tpmesh

ngsolve/__console.py

@@ -0,0 +1,94 @@
+import code
+# import ngfemcf
+# import ngmpi
+
+def mydir(x=None):
+    if x==None:
+        return []
+    else:
+        return [i for i in dir(x) if not '__' in i]
+
+def execfile(fname):
+    exec(open(fname).read())
+
+class InteractiveMPIConsole(code.InteractiveConsole):
+# Function copied from /usr/lib/python3.4/code.py line 38 
+    def runsource(self, source, filename="<input>", symbol="single"):
+        try:
+            compiled_code = self.compile(source, filename, symbol)
+        except (OverflowError, SyntaxError, ValueError):
+            # Case 1
+            self.showsyntaxerror(filename)
+            return False
+
+        if compiled_code is None:
+            # Case 2
+            return True
+
+        # Case 3 -- first send code to other mpi processes
+        ngmpi.SendCommand('ngs_py '+source)
+        # then run it on master
+        code.InteractiveConsole.runcode(self, compiled_code)
+
+        # Avoid the prompt to show up before other processes' output
+        self.Barrier()
+        return False
+
+    def interact(self):
+        import sys
+        self.write("MPI Shell\n")
+        self.write("================\n")
+        self.write("Use pprint(str) to print with MPI ranks\n\n")
+        self.runsource("from ngmpi import *\n")
+        self.runsource("pprint=lambda p='':print('Process ' + str(ngmpi.Rank()) + '\\n'+str(p)+'\\n')\n")
+        self.locals.update(locals())
+        self.locals.update(globals())
+        sys.ps1 = "MPI >>> "
+        sys.ps2 = "MPI ... "
+        code.InteractiveConsole.interact(self,'')
+        sys.ps1 = ">>> "
+        sys.ps2 = "... "
+    def Barrier(self):
+        source = 'ngmpi.Barrier()'
+        ngmpi.SendCommand('ngs_py '+source)
+        code.InteractiveConsole.runsource(self, source)
+
+
+
+def MpiShell():
+    import code
+    try:
+        import readline
+        import rlcompleter
+        readline.parse_and_bind("tab:complete") # autocomplete
+    except:
+        try:
+            import pyreadline as readline
+            import rlcompleter
+            readline.parse_and_bind("tab:complete") # autocomplete
+        except:
+            print('readline not found')
+    vars2 = globals()
+    vars2.update(locals())
+    mshell = InteractiveMPIConsole(vars2)
+    mshell.interact()
+
+def startConsole(vars2):
+    try:
+        import readline
+        import rlcompleter
+        if 'libedit' in readline.__doc__:
+            readline.parse_and_bind("bind ^I rl_complete")
+        else:
+            readline.parse_and_bind("tab: complete")
+    except:
+        try:
+            import pyreadline as readline
+            import rlcompleter
+            readline.parse_and_bind("tab:complete") # autocomplete
+        except:
+            print('readline not found')
+    shell = code.InteractiveConsole(vars2)
+    shell.push('from netgen import *')
+    shell.push('from ngsolve import *')
+    shell.interact(banner="NGS-Python console is up ...")

ngsolve/__expr.py

@@ -0,0 +1,181 @@
+###############################################
+# Expression classes                          
+###############################################
+
+def Expr(a):
+    if isinstance(a, BaseExpr):
+        return a
+    try:
+        return a.expr
+    except:
+        raise TypeError('cannot convert ' + str(type(a)) + ' to expression')
+    
+def expr_add(a,b):
+    return Expr(a) + Expr(b)
+
+def expr_sub(a,b):
+    return Expr(a) - Expr(b)
+
+def expr_neg(a):
+    return -Expr(a)
+
+def expr_mul(a,b):
+    return Expr(a) * Expr(b)
+
+def expr_rmul(b,a): # rmul -> swap a,b
+    return a * Expr(b)
+
+def expr_data(a,b):
+    Expr(b).AssignTo(Expr(a))
+
+class BaseExpr:
+    def copy(self):
+        return self.__class__(self.a, self.s)
+
+    def Scale(self, s):
+        res = self.copy()
+        res.s*=s
+        return res
+
+    def __init__(self, a, s=1.0):
+        self.a = a
+        self.s = s
+    
+    def __rmul__(self, other):
+        return self.Scale(other)
+
+    def __add__(self, other):
+        return SumExpr(self, Expr(other))
+
+    def __sub__(self, other):
+        return SumExpr(self, Expr(other).Scale(-1))
+    
+    def __neg__(self):
+        return self.Scale(-1)
+    
+    def __str__(self):
+        return str(self.s) + '*' +str(self.a)
+
+    def __len__(self):
+        return len(self.a)
+
+    def T(self):
+        return TransExpr(self)
+
+class VecExpr(BaseExpr):
+    def AssignTo(self, v, s = 1.0):
+        v.a.Assign(self.a,s*self.s)
+    
+    def AddTo(self, v, s = 1.0):
+        try:
+            v.a.Add(self.a,s*self.s)     
+        except:
+            print ("WARNING: add to exception")
+            v.a += self.a
+
+
+class MatExpr(BaseExpr):
+    def MultScale(self, s, x, y):
+        self.a.MultScale(s*self.s*x.s,x.a,y.a)
+
+    def MultTrans(self, s, x, y):
+        self.a.MultTrans(s*self.s*x.s,x.a,y.a)
+
+    def MultAdd(self, s, x, y):
+        self.a.MultAdd(s*self.s*x.s,x.a,y.a)
+
+    def MultTransAdd(self, s, x, y):
+        self.a.MultTransAdd(s*self.s*x.s,x.a,y.a)
+
+    def __mul__(self, other):
+        if isinstance(Expr(other), VecExpr):
+            return MatVecExpr(self, Expr(other))
+        try:
+            return self.Scale(float(other))
+        except:
+            return None
+
+    def __len__(self):
+        return self.a.Height()
+
+
+class TransExpr(MatExpr):
+    def __init__(self, matexpr, s=1.0):
+        self.a = Expr(matexpr).a
+        self.s = s*Expr(matexpr).s
+
+    def MultScale(self, s, x, y):
+        self.a.MultTrans(s*self.s,x.a,y.a)
+
+    def MultTrans(self, s, x, y):
+        self.a.MultScale(s*self.s,x.a,y.a)
+
+    def MultAdd(self, s, x, y):
+        self.a.MultTransAdd(s*self.s,x.a,y.a)
+
+    def MultTransAdd(self, s, x, y):
+        self.a.MultAdd(s*self.s,x.a,y.a)
+    
+class BinExpr(BaseExpr):
+    def __init__(self, a,b):
+        self.a = Expr(a)
+        self.b = Expr(b)
+
+    def copy(self):
+        return BinExpr(a,b)
+
+    def __str__(self):
+        return str(self.a) + ' op ' + str(self.b)
+
+
+class SumExpr(BinExpr):
+    def Scale(self, s):
+        return SumExpr(self.a.Scale(s), self.b.Scale(s))
+
+    def AssignTo(self, v, s = 1.0):
+        self.a.AssignTo(v, s)
+        self.b.AddTo(v, s)
+
+    def AddTo(self, v, s = 1.0):
+        self.a.AddTo(v, s)
+        self.b.AddTo(v, s)
+
+    def __str__(self):
+        return str(self.a) + ' + ' + str(self.b)
+        
+
+class MatVecExpr(BinExpr):
+    def Scale(self, s):
+        return MatVecExpr(self.a.Scale(s), self.b)
+
+    def AssignTo(self, v, s = 1.0):
+        self.a.MultScale(s,self.b,v)
+
+    def AddTo(self, v, s = 1.0):
+        self.a.MultAdd(s,self.b,v)
+
+    def __str__(self):
+        return str(self.a) + ' * ' + str(self.b)
+
+        
+def GetSlice(self, index):
+    if not isinstance(index,slice):
+        return self.Get(index)
+    index = index.indices(len(self))
+    if(index[2]!=1):
+        print("Slicing with 3 parameters not supported!")
+        return none
+    return self.Range(index[0], index[1])
+
+def SetSlice(self, index, other):
+    if not isinstance(index,slice):
+        self.Set(index, other)
+        return
+    index = index.indices(len(self))
+    if(index[2]!=1):
+        print("Slicing with 3 parameters not supported!")
+        return none
+    Expr(other).AssignTo(self.Range(index[0], index[1]).expr)
+
+
+

ngsolve/__init__.py

@@ -0,0 +1,148 @@
+"""
+NGSolve
+=======
+
+A high order finite element library
+
+Modules:
+ngsolve.bla .... simple vectors and matrices
+ngsolve.fem .... finite elements and integrators
+ngsolve.comp ... function spaces, forms
+"""
+import atexit
+import os, sys
+
+from . import config
+
+import netgen
+
+if config.is_python_package and sys.platform.startswith('win'):
+    netgen_dir = os.path.dirname(netgen.__file__)
+    os.add_dll_directory(netgen_dir)
+    os.environ["PATH"] += os.pathsep + netgen_dir
+
+if config.USE_MKL and config.MKL_LINK == 'sdl':
+    import importlib.metadata
+    try:
+        importlib.metadata.version('mkl')
+        import ctypes
+        for f in importlib.metadata.files('intel_openmp'):
+            if f.match('*libiomp?.so') or f.match('*libiomp?md.dll'):
+                ctypes.CDLL(str(f.locate()), mode=ctypes.RTLD_GLOBAL)
+        for f in importlib.metadata.files('mkl'):
+            if f.match('*mkl_rt*'):
+                ctypes.CDLL(str(f.locate()), mode=ctypes.RTLD_GLOBAL)
+    except importlib.metadata.PackageNotFoundError:
+        pass
+
+from .ngslib import __version__, ngstd, bla, la, fem, comp, solve
+
+from netgen import Redraw, TimeFunction
+
+from pyngcore import BitArray, TaskManager, SetNumThreads, PajeTrace, Timers, Timer
+from .ngstd import IntRange
+from .bla import Matrix, Vector, InnerProduct, Norm
+from .la import BaseMatrix, BaseVector, BlockVector, MultiVector, BlockMatrix, \
+    CreateVVector, CGSolver, QMRSolver, GMRESSolver, ArnoldiSolver, \
+    Projector, DiagonalMatrix, IdentityMatrix, Embedding, PermutationMatrix, \
+    ConstEBEMatrix, ParallelMatrix, PARALLEL_STATUS
+from .fem import BFI, LFI, CoefficientFunction, Parameter, ParameterC, ET, \
+    POINT, SEGM, TRIG, QUAD, TET, PRISM, PYRAMID, HEX, CELL, FACE, EDGE, \
+    VERTEX, FACET, ELEMENT, sin, cos, tan, atan, acos, asin, sinh, cosh, \
+    exp, log, sqrt, erf, floor, ceil, Conj, atan2, pow, Sym, Skew, Id, Trace, Inv, Det, Cof, Cross, \
+    Zero as ZeroCF, \
+    specialcf, BlockBFI, BlockLFI, CompoundBFI, CompoundLFI, BSpline, \
+    IntegrationRule, IfPos, VoxelCoefficient, CacheCF, PlaceholderCF
+from .comp import VOL, BND, BBND, BBBND, COUPLING_TYPE, ElementId, \
+    BilinearForm, LinearForm, GridFunction, Preconditioner, \
+    MultiGridPreconditioner, ElementId, FESpace, ProductSpace, H1, HCurl, \
+    HDiv, L2, VectorH1, VectorL2, SurfaceL2, TangentialSurfaceL2, HDivDiv, HCurlCurl, HCurlDiv, \
+    HDivSurface, HDivDivSurface, FacetFESpace, TangentialFacetFESpace, \
+    NormalFacetFESpace, NormalFacetSurface, \
+    FacetSurface, VectorSurfaceL2, VectorFacetFESpace, VectorFacetSurface, \
+    NodalFESpace, VectorNodalFESpace, H1LumpingFESpace, \
+    NumberSpace, Periodic, Discontinuous, Hidden, VectorValued, MatrixValued, Compress, \
+    CompressCompound, PlateauFESpace, BoundaryFromVolumeCF, Interpolate, Variation, \
+    Integrate, Region, SymbolicLFI, SymbolicBFI, \
+    SymbolicEnergy, Mesh, NodeId, ConvertOperator, ORDER_POLICY, VTKOutput, SetHeapSize, \
+    SetTestoutFile, ngsglobals, pml, ContactBoundary, PatchwiseSolve, \
+    HCurlAMG, APhiHCurlAMG
+from .solve import Draw, \
+    SetVisualization
+from .utils import x, y, z, dx, ds, grad, Grad, curl, div, Deviator, PyId, PyTrace, \
+    PyDet, PyCross, PyCof, PyInv, PySym, PySkew, OuterProduct, PrivateSpace, Normalize, printonce
+
+from . import solvers
+from . import preconditioners
+from . import timestepping
+from .solve_implementation import Solve
+
+try:
+    from netgen.occ import unit_square, unit_cube
+except:
+    pass
+
+CF = CoefficientFunction
+
+from math import pi
+
+from builtins import sum as builtin_sum
+def sum(iterable, start=None):
+    """NGSolve sum function that uses the first element of an iterable as
+start argument if no start argument is provided."""
+    if start is not None:
+        return builtin_sum(iterable, start)
+    generator = iter(iterable)
+    try:
+        first = next(generator)
+    except StopIteration:
+        return 0
+    return builtin_sum(generator, first)
+
+from .timing import Timing
+
+# add flags docu to docstring
+def _add_flags_doc(module):
+    all_classes = module.__dict__
+    for classname in all_classes:
+        instance = all_classes[classname]
+        try:
+            flags_doc = instance.__flags_doc__()
+            if instance.__doc__ == None:
+                instance.__doc__ = ""
+            if not "Keyword arguments can be" in instance.__doc__:
+                instance.__doc__ += "\n Keyword arguments can be:\n"
+                for name in flags_doc:
+                    instance.__doc__ += name + ": " + flags_doc[name] + "\n"
+        except AttributeError:
+            pass
+
+_add_flags_doc(comp)
+
+# from . import __expr
+# BaseVector.expr = property(__expr.VecExpr)
+# BaseVector.data = property(__expr.Expr, __expr.expr_data)
+# BaseVector.__add__ = __expr.expr_add
+# BaseVector.__sub__ = __expr.expr_sub
+# BaseVector.__neg__ = __expr.expr_neg
+# BaseVector.__rmul__ = __expr.expr_rmul
+
+# BaseMatrix.expr = property(__expr.MatExpr)
+# BaseMatrix.data = property(__expr.Expr, __expr.expr_data)
+# BaseMatrix.T = property(__expr.TransExpr)
+# BaseMatrix.__mul__ = __expr.expr_mul
+# BaseMatrix.__rmul__ = __expr.expr_rmul
+# BaseMatrix.__neg__ = __expr.expr_neg
+
+def _jupyter_nbextension_paths():
+    return [
+        {
+            "section": "notebook",
+            "src": "nbextension/static",
+            "dest": "ngsolve_jupyter_widgets",
+            "require": "ngsolve_jupyter_widgets/extension",
+        }
+    ]
+
+atexit.register(solve.__Cleanup)
+