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

ngsolve/demos/mpi/mpi_poisson.py

@@ -0,0 +1,89 @@
+# 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

@@ -0,0 +1,82 @@
+# 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.py

@@ -0,0 +1,26 @@
+from ngsolve import BaseMatrix, BitArray, BilinearForm, BaseVector
+
+class SuperLU(BaseMatrix):
+    # def __init__(self, a: BaseMatrix | BilinearForm, freedofs: BitArray = None):
+    def __init__(self, a, freedofs: BitArray = None):        
+        super().__init__()
+        self.a = a
+        self.freedofs = freedofs
+
+    def Update(self):
+        import scipy.sparse as sp
+        import scipy.sparse.linalg as spla
+        a = self.a if isinstance(self.a, BaseMatrix) else self.a.mat
+        mat = sp.csr_matrix(a.CSR())
+        if self.freedofs is not None:
+            self.fd = list(self.freedofs)
+            mat = mat[self.fd,:][:,self.fd]
+        self.lu = spla.factorized(sp.csc_matrix(mat))
+
+    def Mult(self, x: BaseVector, y: BaseVector):
+        if not hasattr(self, "lu"):
+            self.Update()
+        if self.freedofs is not None:
+            y.FV().NumPy()[self.fd] = self.lu(x.FV().NumPy()[self.fd])
+        else:
+            y.FV().NumPy()[:] = self.lu(x.FV().NumPy())

ngsolve/eigenvalues.py

@@ -0,0 +1,364 @@
+from ngsolve.la import InnerProduct, MultiVector
+from math import sqrt
+from ngsolve import Projector, Norm, Matrix, Vector, IdentityMatrix
+
+def Orthogonalize (vecs, mat):
+    mv = []
+    for i in range(len(vecs)):
+        for j in range(i):
+            vecs[i] -= InnerProduct(vecs[i], mv[j]) * vecs[j]
+            
+        hv = mat.CreateRowVector()
+        hv.data = mat * vecs[i]
+        norm = sqrt(InnerProduct(vecs[i], hv))
+        vecs[i] *= 1/norm
+        hv *= 1/norm
+        mv.append (hv)
+
+
+def PINVIT1(mata, matm, pre, num=1, maxit=20, printrates=True, GramSchmidt=False):
+    """preconditioned inverse iteration"""
+    import scipy.linalg
+
+    r = mata.CreateRowVector()
+    Av = mata.CreateRowVector()
+    Mv = mata.CreateRowVector()
+
+    uvecs = []
+    for i in range(num):
+        uvecs.append (mata.CreateRowVector())
+    
+    vecs = []
+    for i in range(2*num):
+        vecs.append (mata.CreateRowVector())
+
+    for v in uvecs:
+        r.SetRandom()
+        v.data = pre * r
+
+    asmall = Matrix(2*num, 2*num)
+    msmall = Matrix(2*num, 2*num)
+    lams = num * [1]
+
+    for i in range(maxit):
+        
+        for j in range(num):
+            vecs[j].data = uvecs[j]
+            r.data = mata * vecs[j] - lams[j] * matm * vecs[j]
+            vecs[num+j].data = pre * r
+
+        if GramSchmidt:
+            Orthogonalize (vecs, matm)
+
+        for j in range(2*num):
+            Av.data = mata * vecs[j]
+            Mv.data = matm * vecs[j]
+            for k in range(2*num):
+                asmall[j,k] = InnerProduct(Av, vecs[k])
+                msmall[j,k] = InnerProduct(Mv, vecs[k])
+
+        ev,evec = scipy.linalg.eigh(a=asmall, b=msmall)
+        lams[:] = ev[0:num]
+        if printrates:
+            print (i, ":", lams)
+    
+        for j in range(num):
+            uvecs[j][:] = 0.0
+            for k in range(2*num):
+                uvecs[j].data += float(evec[k,j]) * vecs[k]
+
+    return lams, uvecs
+
+
+
+
+def PINVIT(mata, matm, pre, num=1, maxit=20, printrates=True, GramSchmidt=True):
+    """preconditioned inverse iteration"""
+    import scipy.linalg
+
+    r = mata.CreateRowVector()
+    
+    uvecs = MultiVector(r, num)
+    vecs = MultiVector(r, 2*num)
+    # hv = MultiVector(r, 2*num)
+
+    for v in vecs[0:num]:
+        v.SetRandom()
+    uvecs[:] = pre * vecs[0:num]
+    lams = Vector(num * [1])
+    
+    for i in range(maxit):
+        vecs[0:num] = mata * uvecs - (matm * uvecs).Scale (lams)
+        vecs[num:2*num] = pre * vecs[0:num]
+        vecs[0:num] = uvecs
+
+        vecs.Orthogonalize(matm)
+
+        # hv[:] = mata * vecs
+        # asmall = InnerProduct (vecs, hv)
+        # hv[:] = matm * vecs
+        # msmall = InnerProduct (vecs, hv)
+        asmall = InnerProduct (vecs, mata * vecs)
+        msmall = InnerProduct (vecs, matm * vecs)
+    
+        ev,evec = scipy.linalg.eigh(a=asmall, b=msmall)
+        lams = Vector(ev[0:num])
+        if printrates:
+            print (i, ":", list(lams))
+
+        uvecs[:] = vecs * Matrix(evec[:,0:num])
+    return lams, uvecs
+
+
+def LOBPCG(mata, matm, pre, num=1, maxit=20, initial=None, printrates=True, largest=False):
+    """Knyazev's cg-like extension of PINVIT"""
+    import scipy.linalg
+
+    r = mata.CreateRowVector()
+
+    if initial:
+        num=len(initial)
+        uvecs = initial
+    else:
+        uvecs = MultiVector(r, num)
+
+    vecs = MultiVector(r, 3*num)
+    for v in vecs:
+        r.SetRandom()
+        v.data = pre * r
+
+    if initial:
+         vecs[0:num] = uvecs       
+        
+    lams = Vector(num * [1])
+    
+    for i in range(maxit):
+        uvecs.data = mata * vecs[0:num] - (matm * vecs[0:num]).Scale (lams)
+        vecs[2*num:3*num] = pre * uvecs
+        
+        vecs.Orthogonalize(matm)
+
+        asmall = InnerProduct (vecs, mata * vecs)
+        msmall = InnerProduct (vecs, matm * vecs)
+    
+        ev,evec = scipy.linalg.eigh(a=asmall, b=msmall)
+
+        if not largest:
+            lams = Vector(ev[0:num])
+            if printrates:
+                print (i, ":", list(lams), flush=True)
+
+            uvecs[:] = vecs * Matrix(evec[:,0:num])
+            vecs[num:2*num] = vecs[0:num]
+            vecs[0:num] = uvecs
+        else:
+            lams = Vector(ev[2*num:3*num])
+            if printrates:
+                print (i, ":", list(lams), flush=True)
+
+            uvecs[:] = vecs * Matrix(evec[:,2*num:3*num])
+            vecs[num:2*num] = vecs[0:num]
+            vecs[0:num] = uvecs
+        
+    return lams, uvecs
+
+
+
+
+
+def Arnoldi (mat, tol=1e-10, maxiter=200):
+    import scipy.linalg
+    H = Matrix(maxiter,maxiter, complex=mat.is_complex)
+    H[:,:] = 0
+    v = mat.CreateVector(colvector=False)
+    abv = MultiVector(v, 0)
+    v.SetRandom()
+    v /= Norm(v)
+
+    for i in range(maxiter):
+        abv.Append(v)
+        v = (mat*v).Evaluate()
+        for j in range(i+1):
+            H[j,i] = InnerProduct(v, abv[j])
+            v -= H[j,i]*abv[j]
+        if i+1 < maxiter:
+            H[i+1,i] = Norm(v)
+        v = 1/Norm(v)*v
+
+    lam,ev = scipy.linalg.eig(H)
+    return Vector(lam), (abv*Matrix(ev)).Evaluate()
+    
+    
+
+
+
+
+
+# SOAR: A SECOND-ORDER ARNOLDI METHOD FOR THE SOLUTION OF THE QUADRATIC EIGENVALUE PROBLEM
+# Z. Bai and Y. Su, SIAM J. Matrix Anal. Appl 26, pp 640-659 (2005)
+# author: A. Schoefl
+
+def SOAR (A, B, maxiter=200):
+# first version without memory saving and breakdown 
+
+    q = A.CreateVector()
+    p = A.CreateVector()
+    s = A.CreateVector()
+    r = A.CreateVector()
+
+    Q = MultiVector(q,0)
+    P = MultiVector(p,0)
+    p[:] = 0
+    q.SetRandom()
+    q.FV().imag = 0      
+    q /= Norm(q)
+    T = Matrix(maxiter, complex=A.is_complex)
+    T[:,:] = 0
+    
+    for j in range(maxiter):
+        Q.Append(q)
+        P.Append(p)
+        r.data = A*q + B*p
+        s.data = q
+
+        for i in range(j+1):
+
+            T[i,j] = InnerProduct(r, Q[i])
+            r -= T[i,j]*Q[i]
+            s -= T[i,j]*P[i]
+        
+        if j+1 < maxiter:
+            T[j+1,j] = Norm(r)
+            if T[j+1,j] == 0:
+                print("SOAR stopped at iteration j = ", j)
+                break
+
+            q.data = 1/T[j+1,j]*r
+            p.data = 1/T[j+1,j]*s
+
+    return Q
+
+
+
+
+# author: A. Schoefl
+def TOAR (A, B, maxiter=200):
+
+    r = A.CreateVector()
+
+    tmp_np = np.zeros((len(r), 2))#, dtype=complex)
+    r.SetRandom()
+    r.FV().imag = 0      
+    r /= Norm(r)
+    tmp_np[:,0] = r.FV().real
+    r.SetRandom()
+    r.FV().imag = 0      
+    r /= Norm(r)
+    tmp_np[:,1] = r.FV().real
+
+    # tmp_np[:,1] = tmp_np[:,0] # just for testing
+
+
+    Q_np, X_np, perm = la.qr(tmp_np, pivoting=True, mode="economic")
+    # print(Q_np)
+    # print(Q_np.shape, X_np.shape, X_np)
+
+    Q = MultiVector(r,0)
+    # r.FV().NumPy()[:] = Q_np[:,0]
+    
+    r.FV().real[:] = Q_np[:,0]
+    r.FV().imag = 0
+    Q.Append(r)
+    # assign rank
+    if np.isclose(X_np[1,1], 0):
+        eta = 1
+    else:
+        eta = 2
+
+        # r.FV().NumPy()[:] = Q_np[:,1]
+        r.FV().real[:] = Q_np[:,1]
+        r.FV().imag = 0
+        Q.Append(r)
+
+    # print (Q_np)
+    # print (Q[0], Q[1])
+    print (InnerProduct(Q,Q))
+        
+    gamma = np.linalg.norm(tmp_np, ord='fro')
+    
+    U1 = Matrix(eta,1, True) 
+    U1.NumPy()[:,0] = X_np[:eta,1]/gamma
+
+    U2 = Matrix(eta,1, True) 
+    U2.NumPy()[:,0] = X_np[:eta,0]/gamma
+    print ("X_nb = ", X_np[:eta,:])
+    print ("U1 = ", U1)
+    print ("U2 = ", U2)
+
+    H = Matrix(maxiter, maxiter-1, True)
+
+    # TODO: would be more efficient in C++
+    for j in range(maxiter-1):
+
+        # print(U1, "\n", U2)
+
+        r.data = A*(Q*U1[:,j])+B*(Q*U2[:,j])
+        s = Vector(eta, True)
+        # MGS: orthogonalize r against Q
+        for i in range(eta):
+            s[i] = InnerProduct(r, Q[i], conjugate=True) # TODO: order of Q[i], r correct? 
+            r-=s[i]*Q[i]
+        alpha = InnerProduct(r,r, conjugate=True).real
+        
+        # MGS 
+        for i in range(j):
+            # TODO: I have to re-read in proof if should be conjugation makes sense
+            # (currently everything is real valued)
+            H[i,j] = InnerProduct(s, U1[:,i], conjugate=False) + \
+                        InnerProduct( U1[:,j], U2[:,i], conjugate=True)
+            s -= H[i,j]*U1[:,i]
+            U1[:,j] -= H[i,j]*U2[:,i]
+
+        H[j+1,j] = sqrt(alpha+InnerProduct(s,s,conjugate=True).real+
+                    InnerProduct(U1[:,j],U1[:,j], conjugate=True).real)
+
+        alpha = sqrt(alpha)
+
+        # breakdown
+        if H[j+1,j] == 0: 
+            print("breakdown in iteration ", j)
+            return Q
+
+        # deflation
+        if alpha == 0:
+            print("deflation in iteration ", j)
+            tmp = U1
+            U1 = Matrix(eta, j+2, True) 
+            U1[:,:j+1] = tmp
+            U1[:,j+1] = 1/H[j+1,j]*s
+
+            tmp = U2
+            U2 = Matrix(eta, j+2, True) 
+            U2[:,:j+1] = tmp
+            U2[:,j+1] = 1/H[j+1,j]*U1[:,j]
+        else:
+            # update rank
+            eta+=1
+
+            tmp = U2
+            U2 = Matrix(eta, j+2, True) 
+            U2[:-1,:j+1] = tmp
+            U2[:-1,j+1] = 1/H[j+1,j]*U1[:,j]
+            U2[eta-1, :] = 0
+
+            tmp = U1
+            U1 = Matrix(eta, j+2, True) 
+            U1[:-1,:j+1] = tmp[:,:]
+            U1[:-1,j+1] = 1/H[j+1,j]*s
+            U1[eta-1, j+1] = alpha/H[j+1,j]
+
+            Q.Append(1/alpha*r)                        
+
+
+    return Q
+

ngsolve/internal.py

@@ -0,0 +1,89 @@
+#######################################################
+# Visualization settings
+
+import ngsolve.solve
+import os
+
+# list of possible attributes -- necessary to provide autocompletion
+visoptions_variables = ['usetexture', 'invcolor', 'imaginary', 'lineartexture', 'numtexturecols', 'showclipsolution', 'showsurfacesolution', 'drawfieldlines', 'drawpointcurves', 'numfieldlines', 'fieldlinesrandomstart', 'fieldlinesstartarea', 'fieldlinesstartareap1x', 'fieldlinesstartareap1y', 'fieldlinesstartareap1z', 'fieldlinesstartareap2x', 'fieldlinesstartareap2y', 'fieldlinesstartareap2z', 'fieldlinesstartface', 'fieldlinesfilename', 'fieldlinestolerance', 'fieldlinesrktype', 'fieldlineslength', 'fieldlinesmaxpoints', 'fieldlinesthickness', 'fieldlinesvecfunction', 'fieldlinesphase', 'fieldlinesonlyonephase', 'lineplotfile', 'lineplotsource', 'lineplotusingx', 'lineplotusingy', 'lineplotautoscale', 'lineplotxmin', 'lineplotxmax', 'lineplotymin', 'lineplotymax', 'lineplotcurrentnum', 'lineplotinfos', 'lineplotselected', 'lineplotselector', 'lineplotcolor', 'lineplotsizex', 'lineplotsizey', 'lineplotselectedeval', 'lineplotdatadescr', 'lineplotxcoordselector', 'lineplotycoordselector', 'evaluatefilenames', 'evaluatefiledescriptions', 'clipsolution', 'scalfunction', 'vecfunction', 'evaluate', 'gridsize', 'xoffset', 'yoffset', 'autoscale', 'redrawperiodic', 'logscale', 'mminval', 'mmaxval', 'isolines', 'isosurf', 'subdivisions', 'numiso', 'autoredraw', 'autoredrawtime', 'simulationtime', 'multidimcomponent', 'deformation', 'scaledeform1', 'scaledeform2']
+
+viewoptions_variables = ['specpointvlen', 'colormeshsize', 'whitebackground', 'drawcoordinatecross', 'drawcolorbar', 'drawnetgenlogo', 'stereo', 'shrink', 'drawfilledtrigs', 'drawedges', 'drawbadels', 'centerpoint', 'drawelement', 'drawoutline', 'drawtets', 'drawtetsdomain', 'drawprisms', 'drawpyramids', 'drawhexes', 'drawidentified', 'drawpointnumbers', 'drawedgenumbers', 'drawfacenumbers', 'drawelementnumbers', 'drawdomainsurf', 'drawededges', 'drawedpoints', 'drawedpointnrs', 'drawedtangents', 'drawededgenrs', 'drawmetispartition', 'drawcurveproj', 'drawcurveprojedge', 'usecentercoords', 'centerx', 'centery', 'centerz', 'drawspecpoint', 'specpointx', 'specpointy', 'specpointz']
+
+clipping_variables = ['nx', 'ny', 'nz', 'dist', 'dist2', 'enable', 'onlydomain', 'notdomain']
+
+class TclVariables:
+    def __init__(self, name, update_cmd, attributes = []):
+        object.__setattr__(self, '_name', name)
+        object.__setattr__(self, '_update_cmd', update_cmd)
+        object.__setattr__(self, '_attributes', attributes)
+
+    # set corresponding variable in tcl and call update_cmd
+    def __setattr__(self, attribute_name, value):
+        if not attribute_name in self._attributes:
+            raise KeyError()
+        tcl_string = 'set '+self._name+'.'+attribute_name+' '+str(value)+'; '+self._update_cmd+';\n'
+        ngsolve.solve.Tcl_Eval(tcl_string)
+        ngsolve.Redraw()
+
+    # return list of possible attributes - for autocompletion
+    def __dir__(self):
+        return list(self.__dict__.keys()) + self._attributes
+
+    # rlcomplete checks existence of attribute with this function
+    def __getattr__(self, name):
+        if name in self.__dict__:
+            return self.__dict__[name]
+
+        if name in self._attributes:
+            return True
+        raise Exception()
+    def add_group( self, name, attributes=[] ):
+        self.__dict__[name] = TclVariables(self._name +'.'+name, self._update_cmd, attributes)
+
+
+visoptions = TclVariables('::visoptions', 'Ng_Vis_Set parameters', visoptions_variables)
+viewoptions = TclVariables('::viewoptions', 'Ng_SetVisParameters', viewoptions_variables)
+
+# add subgroups to viewoptions
+viewoptions.add_group( 'clipping', clipping_variables )
+viewoptions.add_group( 'light', ['amb', 'diff', 'spec', 'locviewer'] )
+viewoptions.add_group( 'mat', ['shininess', 'transp'] )
+
+def VideoStart(filename):
+    ngsolve.solve.Tcl_Eval("Ng_VideoClip .ndraw init " + filename+';\n')
+
+def VideoAddFrame():
+    ngsolve.solve.Tcl_Eval("Ng_VideoClip .ndraw addframe;\n")
+
+def VideoFinalize():
+    ngsolve.solve.Tcl_Eval("Ng_VideoClip .ndraw finalize;\n")
+
+def SnapShot(filename):
+    tmp_filename = filename.lower()
+    needs_conversion = not tmp_filename.endswith(".ppm")
+    if needs_conversion:
+        tmp_filename += ".ppm"
+    ngsolve.solve.Tcl_Eval("Ng_SnapShot .ndraw {};\n".format(tmp_filename))
+    ngsolve.Redraw(True)
+
+    if needs_conversion:
+        import time
+        from PIL import Image
+        t0 = time.time()
+        while not os.path.exists(tmp_filename) and time.time()-t0 < 5:
+            time.sleep(0.1)
+        im = Image.open(tmp_filename)
+        im.save(filename)
+        os.remove(tmp_filename)
+
+def Move(dx, dy):
+    ngsolve.solve.Tcl_Eval("Ng_MouseMove 0 0 {} {} move; redraw;\n".format(dx, -dy))
+
+def Rotate(dx, dy):
+    ngsolve.solve.Tcl_Eval("Ng_MouseMove 0 0 {} {} rotate; redraw;\n".format(dx, -dy))
+
+def Zoom(z):
+    ngsolve.solve.Tcl_Eval("Ng_MouseMove 0 0 0 {} zoom; redraw;\n".format(-z))
+
+def Center():
+    ngsolve.solve.Tcl_Eval("Ng_Center; redraw;\n")