ngsPETSc 0.0.7a7__tar.gz

ngspetsc-0.0.7a7/LICENSE.txt

@@ -0,0 +1,10 @@
+MIT License
+
+Copyright (c) 2023 Umberto Zerbinati
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ngspetsc-0.0.7a7/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: ngsPETSc
+Version: 0.0.7a7
+Summary: NGSolve/Netgen interface to PETSc
+Home-page: https://github.com/NGSolve/ngsPETSc
+License: MIT
+Author: Umberto Zerbinati
+Author-email: umberto.zerbinati@maths.ox.ac.uk
+Maintainer: Umberto Zerbinati
+Maintainer-email: umberto.zerbinati@maths.ox.ac.uk
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: mpi4py (>=4,<5)
+Requires-Dist: netgen-mesher (>=6.2,<7.0)
+Requires-Dist: netgen-occt (>=7.8,<8.0)
+Requires-Dist: numpy (>=2,<3)
+Requires-Dist: petsc4py (>=3.22.1,<4.0.0)
+Requires-Dist: scipy (>=1,<2)
+Project-URL: Documentation, https://ngspetsc.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/NGSolve/ngsPETSc
+Description-Content-Type: text/markdown
+
+# ngsPETSc
+
+ngsPETSc is an interface between PETSc and NGSolve/NETGEN that enables the use of NETGEN meshes and geometries in PETSc-based solvers while providing NGSolve users access to the wide array of linear, nonlinear solvers, and time-steppers available in PETSc.
+
+[![ngsPETSc](https://github.com/UZerbinati/ngsPETSc/actions/workflows/ngsPETSc.yml/badge.svg)](https://github.com/UZerbinati/ngsPETSc/actions/workflows/ngsPETSc.yml)
+[![Documentation Status](https://readthedocs.org/projects/ngspetsc/badge/?version=latest)](https://ngspetsc.readthedocs.io/en/latest/?badge=latest)
+
+## Installation
+If you already have NGSolve (with MPI support) and PETSc installed, you can install ngsPETSc via pip:
+```bash
+
+    git clone https://github.com/UZerbinati/ngsPETSc.git
+    cd ngsPETSc
+    pip install .
+```
+Alternatively, you can also build PETSc, SLEPc, and NGSolve from source following the instructions in the [documentation](https://ngspetsc.readthedocs.io/en/latest/installation.html).
+
+## Getting started
+
+To get started with ngsPETSc, check out the [documentation](https://ngspetsc.readthedocs.io/en/latest/).
+To test the installation, you can run the tests in the `tests` folder, via the Makefile in the root directory of the repository:
+```bash
+    make test
+```

ngspetsc-0.0.7a7/README.md

@@ -0,0 +1,24 @@
+# ngsPETSc
+
+ngsPETSc is an interface between PETSc and NGSolve/NETGEN that enables the use of NETGEN meshes and geometries in PETSc-based solvers while providing NGSolve users access to the wide array of linear, nonlinear solvers, and time-steppers available in PETSc.
+
+[![ngsPETSc](https://github.com/UZerbinati/ngsPETSc/actions/workflows/ngsPETSc.yml/badge.svg)](https://github.com/UZerbinati/ngsPETSc/actions/workflows/ngsPETSc.yml)
+[![Documentation Status](https://readthedocs.org/projects/ngspetsc/badge/?version=latest)](https://ngspetsc.readthedocs.io/en/latest/?badge=latest)
+
+## Installation
+If you already have NGSolve (with MPI support) and PETSc installed, you can install ngsPETSc via pip:
+```bash
+
+    git clone https://github.com/UZerbinati/ngsPETSc.git
+    cd ngsPETSc
+    pip install .
+```
+Alternatively, you can also build PETSc, SLEPc, and NGSolve from source following the instructions in the [documentation](https://ngspetsc.readthedocs.io/en/latest/installation.html).
+
+## Getting started
+
+To get started with ngsPETSc, check out the [documentation](https://ngspetsc.readthedocs.io/en/latest/).
+To test the installation, you can run the tests in the `tests` folder, via the Makefile in the root directory of the repository:
+```bash
+    make test
+```

ngspetsc-0.0.7a7/ngsPETSc/__init__.py

@@ -0,0 +1,46 @@
+'''
+ngsPETSc is a NGSolve/Netgen interface to PETSc
+'''
+from ngsPETSc.plex import *
+
+__all__ = []
+
+#Firedrake
+try:
+    import firedrake
+except ImportError:
+    firedrake = None
+
+if firedrake:
+    from ngsPETSc.utils.firedrake.meshes import *
+    from ngsPETSc.utils.firedrake.hierarchies import *
+    __all__ = __all__ + ["FiredrakeMesh", "NetgenHierarchy"]
+
+#FEniCSx
+try:
+    import dolfinx
+except ImportError:
+    dolfinx = None
+
+if dolfinx:
+    from ngsPETSc.utils.fenicsx import *
+
+#Netgen
+try:
+    import ngsolve
+except ImportError:
+    ngsolve = None
+
+if ngsolve:
+    from ngsPETSc.mat import *
+    from ngsPETSc.vec import *
+    from ngsPETSc.nullspace import *
+    from ngsPETSc.pc import *
+    from ngsPETSc.ksp import *
+    from ngsPETSc.snes import *
+    from ngsPETSc.eps import *
+    __all__ = __all__ + ["Matrix","VectorMapping","MeshMapping",
+                         "KrylovSolver","EigenSolver","NullSpace",
+                         "PETScPreconditioner", "NonLinearSolver"]
+
+VERSION = "0.0.5"

ngspetsc-0.0.7a7/ngsPETSc/eps.py

@@ -0,0 +1,184 @@
+'''
+This module contains all the functions related to the SLEPc eigenvalue
+solver (EPS/PEP) interface for NGSolve
+'''
+from petsc4py import PETSc
+try:
+    from slepc4py import SLEPc
+except ImportError:
+    import warnings
+    warnings.warn("Import Warning: it was not possible to import SLEPc")
+    SLEPc = None
+
+from mpi4py import MPI
+
+from ngsolve import GridFunction
+
+from ngsPETSc import Matrix, VectorMapping
+class EigenSolver():
+    """
+    This calss creates a SLEPc Eigen Problem Solver (EPS/PEP) from NGSolve
+    variational problem pencil, i.e.
+    a0(u,v)+lam*a1(u,v)+(lam^2)*a2(u,v)+ ... = 0
+    Inspired by Firedrake Eigensolver class.
+
+    :arg pencil: tuple containing the bilinear forms a: V x V -> K composing
+    the pencil, e.g. (m,a) with a = BilinearForm(grad(u),grad(v)*dx) and
+    m = BilinearForm(-1*u*v*dx)
+
+    :arg fes: finite element space V
+
+    :arg nev: number of requested eigenvalue
+
+    :arg ncv: dimension of the internal subspace used by SLEPc,
+    by Default by SLEPc.DECIDE
+
+    :arg solverParameters: parameters to be passed to the KSP solver
+
+    :arg optionsPrefix: special solver options prefix for this specific Krylov solver
+
+    """
+    if SLEPc is not None:
+        def __init__(self, pencil, fes, nev, ncv=SLEPc.DECIDE, optionsPrefix=None,
+                    solverParameters=None):
+            self.comm = MPI.COMM_WORLD
+            if not isinstance(pencil, tuple): pencil=tuple([pencil])
+            self.penLength = len(pencil)
+            self.fes = fes
+            self.nev = nev
+            self.ncv = ncv
+            self.solverParameters = solverParameters
+            self.optionsPrefix = optionsPrefix
+            options_object = PETSc.Options()
+            if solverParameters is not None:
+                for optName, optValue in self.solverParameters.items():
+                    options_object[optName] = optValue
+
+            self.pencilMats = []
+            self.pencilFlags = []
+            for a in pencil:
+                self.pencilFlags += [a.flags.ToDict()]
+                self.pencilMats += [Matrix(a.Assemble().mat, fes).mat]
+                self.pencilMats[-1].setOptionsPrefix(self.optionsPrefix)
+                self.pencilMats[-1].setFromOptions()
+            self.eps = None
+            self.pep = None
+            if self.penLength > 2:
+                self.isEPS = False
+            else:
+                self.isEPS = True
+                self.setUpEPS()
+
+        def setUpEPS(self):
+            '''
+            This function setup a SLEPc EPS if the pencil has shape either (m,a)
+            or is simply a single matrix. 
+            '''
+            self.eps = SLEPc.EPS().create()
+            self.eps.setType(SLEPc.EPS.Type.KRYLOVSCHUR)
+            if self.penLength == 1:
+                flag0 = self.pencilFlags[0]
+                if "symmetric" in flag0.keys():
+                    if flag0["symmetric"]:
+                        self.eps.setProblemType(SLEPc.EPS.ProblemType.HEP)
+                    else:
+                        self.eps.setProblemType(SLEPc.EPS.ProblemType.NHEP)
+                else:
+                    self.eps.setProblemType(SLEPc.EPS.ProblemType.NHEP)
+                self.eps.setOperators(self.pencilMats[0])
+            else:
+                flag0 = self.pencilFlags[0]
+                flag1 = self.pencilFlags[1]
+                if "symmetric" in flag0.keys() and "symmetric" in flag1.keys():
+                    if flag0["symmetric"] and flag1["symmetric"]:
+                        self.eps.setProblemType(SLEPc.EPS.ProblemType.GHEP)
+                    else:
+                        self.eps.setProblemType(SLEPc.EPS.ProblemType.GNHEP)
+                else:
+                    self.eps.setProblemType(SLEPc.EPS.ProblemType.GNHEP)
+                self.pencilMats[0].scale(-1)
+                self.eps.setOperators(self.pencilMats[1], self.pencilMats[0])
+            self.eps.setDimensions(self.nev, self.ncv)
+            self.eps.setOptionsPrefix(self.optionsPrefix)
+            self.eps.setFromOptions()
+
+        def solve(self):
+            '''
+            This function solve the eigenprobelm
+            '''
+            self.eps.solve()
+            self.nconv = self.eps.getConverged()
+            if self.nconv == 0:
+                raise RuntimeError("Did not converge any eigenvalues.")
+            return self.nconv
+
+        def view(self):
+            '''
+            This function setup display the information about SLEPc EPS/PEP
+            '''
+            self.eps.view()
+
+        def eigenValue(self, i):
+            '''
+            This function return the eigenvalue of the eigenproblem
+
+            :arg i: index of the eigenvalue we are intrested in.
+
+            '''
+            lam = None
+            if self.isEPS:
+                lam = self.eps.getEigenvalue(i)
+            return lam
+
+        def eigenFunction(self, i):
+            '''
+            This function return the eigenfunction of the eigenproblem
+
+            :arg i: index of the eigenfunction we are intrested in.
+
+            '''
+            self.vecMap = VectorMapping(self.fes)
+            eigenModeReal = GridFunction(self.fes)
+            eigenModeImag = GridFunction(self.fes)
+            eignModePETScReal = self.pencilMats[0].createVecLeft()
+            eignModePETScImag = self.pencilMats[0].createVecLeft()
+            if self.isEPS:
+                self.eps.getEigenvector(i, eignModePETScReal, eignModePETScImag)
+            self.vecMap.ngsVec(eignModePETScReal,eigenModeReal.vec)
+            self.vecMap.ngsVec(eignModePETScImag,eigenModeImag.vec)
+            return eigenModeReal, eigenModeImag
+
+        def eigenValues(self, indeces):
+            '''
+            This function return the eigenvalues of the eigenproblem
+
+            :arg indeces: indeces of the eigenvalues we are intrested in.
+
+            '''
+            lams = []
+            if self.isEPS:
+                for i in indeces:
+                    lams = lams + [self.eps.getEigenvalue(i)]
+            return lams
+
+        def eigenFunctions(self, indeces):
+            '''
+            This function return a multidim with 
+            the eigenfunctions of the eigenproblem
+
+            :arg indeces: indeces of the eigenfunctions we are intrested in.
+
+            '''
+            self.vecMap = VectorMapping(self.fes)
+            eigenModesReal = GridFunction(self.fes, multidim=self.nev)
+            eigenModesImag = GridFunction(self.fes, multidim=self.nev)
+            k = 0
+            eignModePETScReal = self.pencilMats[0].createVecLeft()
+            eignModePETScImag = self.pencilMats[0].createVecLeft()
+            for i in indeces:
+                if self.isEPS:
+                    self.eps.getEigenvector(i, eignModePETScReal, eignModePETScImag)
+                self.vecMap.ngsVec(eignModePETScReal,eigenModesReal.vecs[k])
+                self.vecMap.ngsVec(eignModePETScImag,eigenModesImag.vecs[k])
+                k += 1
+            return eigenModesReal, eigenModesImag

ngspetsc-0.0.7a7/ngsPETSc/ksp.py

@@ -0,0 +1,292 @@
+'''
+This module contains all the functions related to the PETSc linear
+system solver (KSP) interface for NGSolve
+'''
+from petsc4py import PETSc
+from ngsolve import la, BilinearForm, FESpace, BitArray, Projector
+from ngsPETSc import Matrix, VectorMapping, PETScPreconditioner, NullSpace
+
+def createFromBilinearForm(a, freeDofs, solverParameters):
+    """
+    This function creates a PETSc matrix from an NGSolve bilinear form
+    """
+    a.Assemble()
+    #Setting deafult matrix type
+    if "ngs_mat_type" not in solverParameters:
+        solverParameters["ngs_mat_type"] = "aij"
+    #Assembling matrix if not of type Python
+    if solverParameters["ngs_mat_type"] not in ["python"]:
+        if hasattr(a.mat, "row_pardofs"):
+            dofs = a.mat.row_pardofs
+        else:
+            dofs = None
+        mat = Matrix(a.mat, (dofs, freeDofs, None), solverParameters["ngs_mat_type"])
+        return (a.mat, mat.mat)
+    raise ValueError("ngs_mat_type {} is not supported.".format(solverParameters["ngs_mat_type"]))
+
+def createFromMatrix(a, freeDofs, solverParameters):
+    """
+    This function creates a PETSc matrix from an NGSolve bilinear form
+    """
+    #Setting deafult matrix type
+    if "ngs_mat_type" not in solverParameters:
+        solverParameters["ngs_mat_type"] = "aij"
+    #Assembling matrix if not of type Python
+    if solverParameters["ngs_mat_type"] not in ["python"]:
+        if hasattr(a, "row_pardofs"):
+            dofs = a.row_pardofs
+        else:
+            dofs = None
+        mat = Matrix(a, (dofs, freeDofs, None), solverParameters["ngs_mat_type"])
+        pscMat = mat.mat
+        return (a, pscMat)
+    if solverParameters["ngs_mat_type"] == "python":
+        _, pscMat = createFromAction(a, freeDofs, solverParameters)
+        return (a, pscMat)
+    raise ValueError("ngs_mat_type {} is not supported.".format(solverParameters["ngs_mat_type"]))
+
+def createFromPC(a, freeDofs, solverParameters):
+    """
+    This function creates a PETSc matrix from an ngsPETSc PETSc Preconditioner
+    """
+    class Wrap(object):
+        """
+        This class wraps a PETSc Preconditioner as PETSc Python matrix
+        """
+        def __init__(self, a, dofs, freeDofs):
+            self.a = a
+            self.mapping = VectorMapping((dofs,freeDofs,{"bsize": [1]}))
+            self.ngX = a.CreateColVector()
+            self.ngY = a.CreateColVector()
+            if hasattr(a, "actingDofs"):
+                self.prj = Projector(mask=a.actingDofs, range=True)
+            else:
+                self.prj = Projector(mask=freeDofs, range=True)
+
+        def mult(self, mat, X, Y): #pylint: disable=W0613
+            """
+            PETSc matrix-vector product
+            """
+            self.mapping.ngsVec(X, (self.prj*self.ngX).Evaluate())
+            self.a.Mult(self.ngX, self.ngY)
+            self.mapping.petscVec((self.prj*self.ngY).Evaluate(), Y)
+    #Grabbing comm information
+    if hasattr(a, "row_pardofs"):
+        dofs = a.row_pardofs
+        comm = dofs.comm.mpi4py
+    elif "dofs" in solverParameters:
+        dofs = solverParameters["dofs"]
+        comm = dofs.comm.mpi4py
+    else:
+        dofs = None
+        comm = PETSc.COMM_SELF
+    pythonA = Wrap(a, dofs, freeDofs)
+    pscA = PETSc.Mat().create(comm=comm)
+    pscA.setSizes([sum(freeDofs), sum(freeDofs)])
+    pscA.setType("python")
+    pscA.setPythonContext(pythonA)
+    pscA.setUp()
+    return (a.ngsMat, pscA)
+
+def createFromAction(a, freeDofs, solverParameters):
+    """
+    This function creates a matrix free PETSc matrix from an NGSolve matrix
+    """
+    class Wrap(object):
+        """
+        This class wraps an NGSolve matrix as PETSc Python matrix
+        """
+        def __init__(self, a, dofs, freeDofs, comm):
+            self.a = a
+            self.dofs = dofs
+            self.freeDofs = freeDofs
+            self.comm = comm
+            self.mapping = VectorMapping((dofs,freeDofs,{"bsize": (1,1)}))
+            self.ngX = a.CreateColVector()
+            self.ngY = a.CreateColVector()
+
+        def mult(self, mat, X, Y): #pylint: disable=W0613
+            """
+            PETSc matrix-vector product
+            """
+            self.mapping.ngsVec(X, self.ngX)
+            self.a.Mult(self.ngX, self.ngY)
+            self.mapping.petscVec(self.ngY, Y)
+
+    if hasattr(a, "row_pardofs"):
+        dofs = a.row_pardofs
+        comm = dofs.comm.mpi4py
+        entrysize = a.local_mat.entrysizes[0]
+        _, rnumberGlobal = dofs.EnumerateGlobally(freeDofs) #samrc
+    elif "dofs" in solverParameters:
+        dofs = solverParameters["dofs"]
+        comm = dofs.comm.mpi4py
+        entrysize = dofs.entrysize
+        _, rnumberGlobal = dofs.EnumerateGlobally(freeDofs) #samrc
+    else:
+        dofs = None
+        comm = PETSc.COMM_SELF
+        entrysize = 1
+        rnumberGlobal = sum(freeDofs)
+    pythonA = Wrap(a, dofs, freeDofs, comm)
+    pscA = PETSc.Mat().create(comm=comm)
+    pscA.setSizes(size=(rnumberGlobal*entrysize,
+                        rnumberGlobal*entrysize), bsize=entrysize)
+    pscA.setType("python")
+    pscA.setPythonContext(pythonA)
+    pscA.setUp()
+    return (a, pscA)
+
+parse = {BilinearForm: createFromBilinearForm,
+         la.SparseMatrixd: createFromMatrix,
+         la.ParallelMatrix: createFromMatrix,
+         PETScPreconditioner: createFromPC,
+         la.BaseMatrix: createFromAction}
+
+class KrylovSolver():
+    """
+    This class creates a PETSc Krylov Solver (KSP) for NGSolve.
+    Inspired by Firedrake linear solver class.
+
+    :arg a: either the bilinear form, ngs Matrix or a petsc4py matrix
+
+    :arg dofsDescr: either finite element space
+
+    :arg p: either the bilinear form, ngs Matrix or petsc4py matrix actin as a preconditioner
+
+    :arg nullspace: either a PETSc NullSpace or ngsPETSc PETSc Preconditioner
+    or touple of ngsPETSc PETSc Preconditioner.
+
+    :arg solverParameters: parameters to be passed to the KS P solver
+
+    :arg optionsPrefix: special solver options prefix for this specific Krylov solver
+
+    """
+    def __init__(self, a, dofsDescr, p=None, nullspace=None, optionsPrefix="",
+                 solverParameters={}):
+        # Grabbing dofs information
+        if isinstance(dofsDescr, FESpace):
+            freeDofs = dofsDescr.FreeDofs()
+        elif isinstance(dofsDescr, BitArray):
+            freeDofs = dofsDescr
+        else:
+            raise ValueError("dofsDescr must be either FESpace or BitArray")
+        #Construct operator
+        pscA = None
+        for key in parse: #pylint: disable=C0206
+            if isinstance(a, key):
+                ngsA, pscA = parse[key](a, freeDofs, solverParameters)
+        if pscA is None:
+            raise ValueError("a of type {} not supported.".format(type(a)))
+        if p is not None:
+            for key in parse:  #pylint: disable=C0206
+                if isinstance(p, key):
+                    if hasattr(ngsA, "row_pardofs"):
+                        solverParameters["dofs"] = ngsA.row_pardofs
+                    _, pscP = parse[key](p, freeDofs, solverParameters)
+                    break
+        else:
+            pscP = pscA
+        #Construct vector mapping
+        if hasattr(ngsA, "row_pardofs"):
+            dofs = ngsA.row_pardofs
+        else:
+            dofs = None
+        if hasattr(ngsA.local_mat, "entrysizes"):
+            entrysize = ngsA.local_mat.entrysizes
+        else:
+            entrysize = [1]
+        self.mapping = VectorMapping((dofs,freeDofs,{"bsize":entrysize}))
+        #Fixing PETSc options
+        options_object = PETSc.Options()
+        for optName, optValue in solverParameters.items():
+            options_object[optName] = optValue
+
+        #Setting PETSc Options
+        pscA.setOptionsPrefix(optionsPrefix)
+        pscA.setFromOptions()
+
+        #Setting up nullspace
+        if nullspace is not None:
+            if isinstance(nullspace, (list, tuple)):
+                for ns in nullspace:
+                    if isinstance(ns, PETSc.NullSpace):
+                        pscA.setNullSpace(ns)
+                    elif isinstance(ns, NullSpace):
+                        if ns.near:
+                            pscA.setNearNullSpace(ns.nullspace)
+                        else:
+                            pscA.setNullSpace(ns.nullspace)
+                    else:
+                        raise ValueError("nullspace must be either \
+                                         PETSc.NullSpace or NullSpace")
+            if isinstance(nullspace, PETSc.NullSpace):
+                pscA.setNullSpace(nullspace)
+            elif isinstance(nullspace, NullSpace):
+                if nullspace.near:
+                    pscA.setNearNullSpace(nullspace.nullspace)
+                else:
+                    pscA.setNullSpace(nullspace.nullspace)
+            else:
+                raise ValueError("nullspace must be either \
+                                    PETSc.NullSpace or NullSpace")
+
+        #Setting up KSP
+        self.ksp = PETSc.KSP().create(comm=pscA.getComm())
+        self.ksp.setOperators(A=pscA, P=pscP)
+        self.ksp.setOptionsPrefix(optionsPrefix)
+        self.ksp.setFromOptions()
+        self.pscX, self.pscB = pscA.createVecs()
+
+        #Attaching operator
+        self.ngsA = ngsA
+
+    def solve(self, b, x, mapping=None):
+        """
+        This function solves the linear system
+
+        :arg b: right hand side of the linear system
+        :arg x: solution of the linear system
+        """
+        if mapping is None:
+            mapping = self.mapping
+        mapping.petscVec(x, self.pscX)
+        mapping.petscVec(b, self.pscB)
+        self.ksp.solve(self.pscB, self.pscX)
+        mapping.ngsVec(self.pscX, x)
+
+    def operator(self):
+        """
+        This function returns the operator of the KSP solver
+        """
+        return KSPOpeator(self)
+
+class KSPOpeator(la.BaseMatrix):
+    """
+    This class wraps a PETSc KSP solver as an NGSolve matrix
+    """
+    def __init__(self, ksp):
+        la.BaseMatrix.__init__(self)
+        self.ksp = ksp
+
+    def Shape(self):
+        '''
+        Shape of the BaseMatrix
+
+        '''
+        return self.ksp.ngsA.shape
+
+    def CreateVector(self,col):
+        '''
+        Create vector corresponding to the matrix
+
+        :arg col: True if one want a column vector
+
+        '''
+        return self.ksp.ngsA.CreateVector(not col)
+
+    def Mult(self, x, y):
+        """
+        Matrix-vector product
+        """
+        self.ksp.solve(x, y)