ngsPETSc 0.0.7a7__py3-none-any.whl

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/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/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)

ngsPETSc/mat.py

@@ -0,0 +1,146 @@
+'''
+This module contains all the functions related to wrapping NGSolve matrices to
+PETSc matrices using the petsc4py interface.
+'''
+import numpy as np
+
+from ngsolve import FESpace
+from petsc4py import PETSc
+
+class Matrix(object):
+    '''
+    This class creates a PETSc Matrix
+
+    :arg ngsMat: the NGSolve matrix
+
+    :arg freeDofs: free DOFs of the FE spaces used to construct the matrix
+
+    :arg matType: type of PETSc matrix, i.e. PETSc sparse: aij,
+    MKL sparse: aijmkl or CUDA: aijcusparse
+
+    '''
+    def __init__(self, ngsMat, parDescr, matType="aij", petscMat=None):
+        if not isinstance(parDescr, (tuple, list)):
+            samerc = True
+            if isinstance(parDescr, FESpace):
+                dofs = parDescr.ParallelDofs()
+                self.freeDofs = (parDescr.FreeDofs(),parDescr.FreeDofs())
+                comm = dofs.comm.mpi4py
+            else:
+                dofs, freeDofs, dofsInfo = parDescr
+                self.freeDofs = (freeDofs,freeDofs)
+                if dofs is not None:
+                    comm = dofs.comm.mpi4py
+                else:
+                    ### create suitable dofs
+                    comm = PETSc.COMM_SELF
+                    dofs = type('', (object,), {'entrysize':dofsInfo["bsize"][0]})()
+        else:
+            samerc = False
+            if isinstance(parDescr[0], FESpace) and isinstance(parDescr[1], FESpace):
+                dofs = parDescr[0].ParallelDofs()
+                self.freeDofs = (parDescr[0].FreeDofs(),parDescr[1].FreeDofs())
+                comm = dofs.comm.mpi4py
+            elif isinstance(parDescr[0], (tuple, list)):
+                dofs = parDescr[0][0]
+                self.freeDofs = (parDescr[0][1], parDescr[1][1])
+                if dofs is not None:
+                    comm = dofs.comm.mpi4py
+                else:
+                    ### create suitable dofs
+                    comm = PETSc.COMM_SELF
+            else:
+                samerc = True
+                dofs = parDescr[0]
+                self.freeDofs = (parDescr[1], parDescr[1])
+                if dofs is not None:
+                    comm = dofs.comm.mpi4py
+                else:
+                    ### create suitable dofs
+                    comm = PETSc.COMM_SELF
+
+        localMat = ngsMat.local_mat
+        entryHeight, entryWidth = localMat.entrysizes
+        if entryHeight != entryWidth: raise RuntimeError ("Only square entries are allowed.")
+
+        valMat, colMat, indMat = localMat.CSR()
+        indMat = np.array(indMat).astype(PETSc.IntType)
+        colMat = np.array(colMat).astype(PETSc.IntType)
+        if entryHeight > 1:
+            petscLocalMat = PETSc.Mat().createBAIJ(size=(entryHeight*localMat.height,
+                                                         entryWidth*localMat.width),
+                                                   bsize=entryHeight,
+                                                   csr=(indMat,colMat,valMat),
+                                                   comm=PETSc.COMM_SELF)
+        else:
+            petscLocalMat = PETSc.Mat().createAIJ(size=(localMat.height,
+                                                        localMat.width),
+                                                  csr=(indMat,colMat,valMat),
+                                                  comm=PETSc.COMM_SELF)
+        if self.freeDofs[0] is not None or self.freeDofs[1] is not None:
+            rowIsFreeLocal = None
+            if self.freeDofs[0] is not None:
+                rowLocalMatFree = np.flatnonzero(self.freeDofs[0]).astype(PETSc.IntType)
+                rowIsFreeLocal = PETSc.IS().createBlock(indices=rowLocalMatFree,
+                                                        bsize=entryHeight,comm=PETSc.COMM_SELF)
+            colIsFreeLocal = rowIsFreeLocal
+            if self.freeDofs[1] is not None and not samerc:
+                colLocalMatFree = np.flatnonzero(self.freeDofs[1]).astype(PETSc.IntType)
+                colIsFreeLocal = PETSc.IS().createBlock(indices=colLocalMatFree,
+                                                        bsize=entryHeight,comm=PETSc.COMM_SELF)
+            petscLocalMat = petscLocalMat.createSubMatrices(rowIsFreeLocal, colIsFreeLocal)[0]
+
+        if comm.Get_size() > 1:
+            # is this a BUG in the bindings?
+            #rparallelDofs = ngsMat.row_pardofs
+            rparallelDofs = ngsMat.col_pardofs
+            rglobalNums, rnumberGlobal = rparallelDofs.EnumerateGlobally(self.freeDofs[0])
+            if self.freeDofs[0] is not None:
+                rglobalNums = np.array(rglobalNums, dtype=PETSc.IntType)[self.freeDofs[0]]
+            rlocalGlobalMap = PETSc.LGMap().create(indices=rglobalNums,
+                                                   bsize=entryHeight,
+                                                   comm=comm)
+            if not samerc:
+                # is this a BUG in the bindings?
+                #cparallelDofs = ngsMat.col_pardofs
+                cparallelDofs = ngsMat.row_pardofs
+                cglobalNums, cnumberGlobal = cparallelDofs.EnumerateGlobally(self.freeDofs[1])
+                if self.freeDofs[1] is not None:
+                    cglobalNums = np.array(cglobalNums, dtype=PETSc.IntType)[self.freeDofs[1]]
+                clocalGlobalMap = PETSc.LGMap().create(indices=cglobalNums,
+                                                       bsize=entryWidth,
+                                                       comm=comm)
+            else:
+                clocalGlobalMap = rlocalGlobalMap
+                cnumberGlobal = rnumberGlobal
+
+            mat = PETSc.Mat().create(comm=comm)
+            mat.setSizes(size=(rnumberGlobal*entryHeight,
+                            cnumberGlobal*entryHeight), bsize=entryHeight)
+            mat.setType(PETSc.Mat.Type.IS)
+            mat.setLGMap(rlocalGlobalMap, clocalGlobalMap)
+            mat.setISLocalMat(petscLocalMat)
+            mat.assemble()
+            if matType != 'is':
+                mat.convert(matType)
+            if petscMat is None:
+                self.mat = mat
+            else:
+                mat.copy(petscMat)
+        else:
+            mat = petscLocalMat
+            mat.convert(matType)
+            if matType != 'is':
+                mat.convert(matType)
+
+            if petscMat is None:
+                self.mat = mat
+            else:
+                mat.copy(petscMat)
+
+    def view(self):
+        '''
+        This function display PETSc Mat info
+
+        '''
+        self.mat.view()