Example #1
0
 def faceDivy(self):
     if (self.dim < 2):
         return None
     if getattr(self, '_faceDivy', None) is None:
         # The number of cell centers in each direction
         n = self.vnC
         # Compute faceDivergence operator on faces
         if (self.dim == 2):
             D2 = sp.kron(ddx(n[1]), speye(n[0]))
         elif (self.dim == 3):
             D2 = kron3(speye(n[2]), ddx(n[1]), speye(n[0]))
         # Compute areas of cell faces & volumes
         S = self.r(self.area, 'F', 'Fy', 'V')
         V = self.vol
         self._faceDivy = sdiag(1 / V) * D2 * sdiag(S)
     return self._faceDivy
Example #2
0
        def fget(self):
            if(self.dim < 2): return None
            if(self._faceDivy is None):
                # The number of cell centers in each direction
                n = self.vnC
                # Compute faceDivergence operator on faces
                if(self.dim == 2):
                    D2 = sp.kron(ddx(n[1]), speye(n[0]))
                elif(self.dim == 3):
                    D2 = kron3(speye(n[2]), ddx(n[1]), speye(n[0]))
                # Compute areas of cell faces & volumes
                S = self.r(self.area, 'F', 'Fy', 'V')
                V = self.vol
                self._faceDivy = sdiag(1/V)*D2*sdiag(S)

            return self._faceDivy
Example #3
0
 def faceDivz(self):
     """Construct divergence operator in the z component (face-stg to cell-centres)."""
     if getattr(self, '_faceDivz', None) is None:
         D3 = kron3(ddx(self.nCz), speye(self.nCy), speye(self.nCx))
         S = self.r(self.area, 'F', 'Fz', 'V')
         V = self.vol
         self._faceDivz = sdiag(1 / V) * D3 * sdiag(S)
     return self._faceDivz
Example #4
0
 def faceDivx(self):
     """Construct divergence operator in the x component (face-stg to cell-centres)."""
     if getattr(self, '_faceDivx', None) is None:
         D1 = kron3(speye(self.nCz), speye(self.nCy), ddx(self.nCx)[:, 1:])
         S = self.r(self.area, 'F', 'Fx', 'V')
         V = self.vol
         self._faceDivx = sdiag(1 / V) * D1 * sdiag(S)
     return self._faceDivx
Example #5
0
 def faceDivx(self):
     """Construct divergence operator in the x component (face-stg to cell-centres)."""
     if getattr(self, '_faceDivx', None) is None:
         D1 = kron3(speye(self.nCz), speye(self.nCy), ddx(self.nCx)[:,1:])
         S = self.r(self.area, 'F', 'Fx', 'V')
         V = self.vol
         self._faceDivx = sdiag(1/V)*D1*sdiag(S)
     return self._faceDivx
Example #6
0
        def fget(self):
            if(self._faceDivx is None):
                # The number of cell centers in each direction
                n = self.vnC
                # Compute faceDivergence operator on faces
                if(self.dim == 1):
                    D1 = ddx(n[0])
                elif(self.dim == 2):
                    D1 = sp.kron(speye(n[1]), ddx(n[0]))
                elif(self.dim == 3):
                    D1 = kron3(speye(n[2]), speye(n[1]), ddx(n[0]))
                # Compute areas of cell faces & volumes
                S = self.r(self.area, 'F', 'Fx', 'V')
                V = self.vol
                self._faceDivx = sdiag(1/V)*D1*sdiag(S)

            return self._faceDivx
Example #7
0
 def faceDivz(self):
     """Construct divergence operator in the z component (face-stg to cell-centres)."""
     if getattr(self, '_faceDivz', None) is None:
         D3 = kron3(ddx(self.nCz), speye(self.nCy), speye(self.nCx))
         S = self.r(self.area, 'F', 'Fz', 'V')
         V = self.vol
         self._faceDivz = sdiag(1/V)*D3*sdiag(S)
     return self._faceDivz
Example #8
0
 def faceDivy(self):
     """Construct divergence operator in the y component (face-stg to cell-centres)."""
     raise NotImplementedError('Wrapping the ddx is not yet implemented.')
     if getattr(self, '_faceDivy', None) is None:
         # TODO: this needs to wrap to join up faces which are connected in the cylinder
         D2 = kron3(speye(self.nCz), ddx(self.nCy), speye(self.nCx))
         S = self.r(self.area, 'F', 'Fy', 'V')
         V = self.vol
         self._faceDivy = sdiag(1 / V) * D2 * sdiag(S)
     return self._faceDivy
Example #9
0
 def faceDivy(self):
     """Construct divergence operator in the y component (face-stg to cell-centres)."""
     raise NotImplementedError('Wrapping the ddx is not yet implemented.')
     if getattr(self, '_faceDivy', None) is None:
         # TODO: this needs to wrap to join up faces which are connected in the cylinder
         D2 = kron3(speye(self.nCz), ddx(self.nCy), speye(self.nCx))
         S = self.r(self.area, 'F', 'Fy', 'V')
         V = self.vol
         self._faceDivy = sdiag(1/V)*D2*sdiag(S)
     return self._faceDivy
Example #10
0
    def faceDivx(self):
        """
        Construct divergence operator in the x component (face-stg to
        cell-centres).
        """
        if getattr(self, '_faceDivx', None) is None:
            # The number of cell centers in each direction
            n = self.vnC
            # Compute faceDivergence operator on faces
            if (self.dim == 1):
                D1 = ddx(n[0])
            elif (self.dim == 2):
                D1 = sp.kron(speye(n[1]), ddx(n[0]))
            elif (self.dim == 3):
                D1 = kron3(speye(n[2]), speye(n[1]), ddx(n[0]))
            # Compute areas of cell faces & volumes
            S = self.r(self.area, 'F', 'Fx', 'V')
            V = self.vol
            self._faceDivx = sdiag(1 / V) * D1 * sdiag(S)

        return self._faceDivx
Example #11
0
    def faceDivx(self):
        """
        Construct divergence operator in the x component (face-stg to
        cell-centres).
        """
        if getattr(self, '_faceDivx', None) is None:
            # The number of cell centers in each direction
            n = self.vnC
            # Compute faceDivergence operator on faces
            if(self.dim == 1):
                D1 = ddx(n[0])
            elif(self.dim == 2):
                D1 = sp.kron(speye(n[1]), ddx(n[0]))
            elif(self.dim == 3):
                D1 = kron3(speye(n[2]), speye(n[1]), ddx(n[0]))
            # Compute areas of cell faces & volumes
            S = self.r(self.area, 'F', 'Fx', 'V')
            V = self.vol
            self._faceDivx = sdiag(1/V)*D1*sdiag(S)

        return self._faceDivx
Example #12
0
 def fget(self):
     if(self._nodalLaplacian is None):
         print 'Warning: Laplacian has not been tested rigorously.'
         # The number of cell centers in each direction
         n = self.vnC
         # Compute divergence operator on faces
         if(self.dim == 1):
             D1 = sdiag(1./self.hx) * ddx(mesh.nCx)
             L  = - D1.T*D1
         elif(self.dim == 2):
             D1 = sdiag(1./self.hx) * ddx(n[0])
             D2 = sdiag(1./self.hy) * ddx(n[1])
             L1 = sp.kron(speye(n[1]+1), - D1.T * D1)
             L2 = sp.kron(- D2.T * D2, speye(n[0]+1))
             L  = L1 + L2
         elif(self.dim == 3):
             D1 = sdiag(1./self.hx) * ddx(n[0])
             D2 = sdiag(1./self.hy) * ddx(n[1])
             D3 = sdiag(1./self.hz) * ddx(n[2])
             L1 = kron3(speye(n[2]+1), speye(n[1]+1), - D1.T * D1)
             L2 = kron3(speye(n[2]+1), - D2.T * D2, speye(n[0]+1))
             L3 = kron3(- D3.T * D3, speye(n[1]+1), speye(n[0]+1))
             L  = L1 + L2 + L3
         self._nodalLaplacian = L
     return self._nodalLaplacian
Example #13
0
 def nodalLaplacian(self):
     """
     Construct laplacian operator (nodes to edges).
     """
     if getattr(self, '_nodalLaplacian', None) is None:
         print('Warning: Laplacian has not been tested rigorously.')
         # The number of cell centers in each direction
         n = self.vnC
         # Compute divergence operator on faces
         if (self.dim == 1):
             D1 = sdiag(1. / self.hx) * ddx(self.nCx)
             L = -D1.T * D1
         elif (self.dim == 2):
             D1 = sdiag(1. / self.hx) * ddx(n[0])
             D2 = sdiag(1. / self.hy) * ddx(n[1])
             L1 = sp.kron(speye(n[1] + 1), -D1.T * D1)
             L2 = sp.kron(-D2.T * D2, speye(n[0] + 1))
             L = L1 + L2
         elif (self.dim == 3):
             D1 = sdiag(1. / self.hx) * ddx(n[0])
             D2 = sdiag(1. / self.hy) * ddx(n[1])
             D3 = sdiag(1. / self.hz) * ddx(n[2])
             L1 = kron3(speye(n[2] + 1), speye(n[1] + 1), -D1.T * D1)
             L2 = kron3(speye(n[2] + 1), -D2.T * D2, speye(n[0] + 1))
             L3 = kron3(-D3.T * D3, speye(n[1] + 1), speye(n[0] + 1))
             L = L1 + L2 + L3
         self._nodalLaplacian = L
     return self._nodalLaplacian
Example #14
0
 def fget(self):
     if(self._nodalLaplacian is None):
         print 'Warning: Laplacian has not been tested rigorously.'
         # The number of cell centers in each direction
         n = self.vnC
         # Compute divergence operator on faces
         if(self.dim == 1):
             D1 = sdiag(1./self.hx) * ddx(mesh.nCx)
             L  = - D1.T*D1
         elif(self.dim == 2):
             D1 = sdiag(1./self.hx) * ddx(n[0])
             D2 = sdiag(1./self.hy) * ddx(n[1])
             L1 = sp.kron(speye(n[1]+1), - D1.T * D1)
             L2 = sp.kron(- D2.T * D2, speye(n[0]+1))
             L  = L1 + L2
         elif(self.dim == 3):
             D1 = sdiag(1./self.hx) * ddx(n[0])
             D2 = sdiag(1./self.hy) * ddx(n[1])
             D3 = sdiag(1./self.hz) * ddx(n[2])
             L1 = kron3(speye(n[2]+1), speye(n[1]+1), - D1.T * D1)
             L2 = kron3(speye(n[2]+1), - D2.T * D2, speye(n[0]+1))
             L3 = kron3(- D3.T * D3, speye(n[1]+1), speye(n[0]+1))
             L  = L1 + L2 + L3
         self._nodalLaplacian = L
     return self._nodalLaplacian
Example #15
0
        def fget(self):
            if(self.dim < 3): return None
            if(self._faceDivz is None):
                # The number of cell centers in each direction
                n = self.vnC
                # Compute faceDivergence operator on faces
                D3 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]))
                # Compute areas of cell faces & volumes
                S = self.r(self.area, 'F', 'Fz', 'V')
                V = self.vol
                self._faceDivz = sdiag(1/V)*D3*sdiag(S)

            return self._faceDivz
Example #16
0
        def fget(self):
            if(self.dim < 3): return None
            if(self._faceDivz is None):
                # The number of cell centers in each direction
                n = self.vnC
                # Compute faceDivergence operator on faces
                D3 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]))
                # Compute areas of cell faces & volumes
                S = self.r(self.area, 'F', 'Fz', 'V')
                V = self.vol
                self._faceDivz = sdiag(1/V)*D3*sdiag(S)

            return self._faceDivz
Example #17
0
 def faceDivz(self):
     """
     Construct divergence operator in the z component (face-stg to
     cell-centres).
     """
     if(self.dim < 3):
         return None
     if getattr(self, '_faceDivz', None) is None:
         # The number of cell centers in each direction
         n = self.vnC
         # Compute faceDivergence operator on faces
         D3 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]))
         # Compute areas of cell faces & volumes
         S = self.r(self.area, 'F', 'Fz', 'V')
         V = self.vol
         self._faceDivz = sdiag(1/V)*D3*sdiag(S)
     return self._faceDivz
Example #18
0
 def faceDivz(self):
     """
     Construct divergence operator in the z component (face-stg to
     cell-centers).
     """
     if (self.dim < 3):
         return None
     if getattr(self, '_faceDivz', None) is None:
         # The number of cell centers in each direction
         n = self.vnC
         # Compute faceDivergence operator on faces
         D3 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]))
         # Compute areas of cell faces & volumes
         S = self.r(self.area, 'F', 'Fz', 'V')
         V = self.vol
         self._faceDivz = sdiag(1 / V) * D3 * sdiag(S)
     return self._faceDivz
Example #19
0
        def fget(self):
            if(self._edgeCurl is None):
                assert self.dim > 1, "Edge Curl only programed for 2 or 3D."
                # The number of cell centers in each direction
                n = self.vnC

                # Compute lengths of cell edges
                L = self.edge

                # Compute areas of cell faces
                S = self.area

                # Compute divergence operator on faces
                if self.dim == 2:

                    D21 = sp.kron(ddx(n[1]), speye(n[0]))
                    D12 = sp.kron(speye(n[1]), ddx(n[0]))
                    C = sp.hstack((-D21, D12), format="csr")
                    self._edgeCurl = C*sdiag(1/S)

                elif self.dim == 3:

                    D32 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]+1))
                    D23 = kron3(speye(n[2]), ddx(n[1]), speye(n[0]+1))
                    D31 = kron3(ddx(n[2]), speye(n[1]+1), speye(n[0]))
                    D13 = kron3(speye(n[2]), speye(n[1]+1), ddx(n[0]))
                    D21 = kron3(speye(n[2]+1), ddx(n[1]), speye(n[0]))
                    D12 = kron3(speye(n[2]+1), speye(n[1]), ddx(n[0]))

                    O1 = spzeros(np.shape(D32)[0], np.shape(D31)[1])
                    O2 = spzeros(np.shape(D31)[0], np.shape(D32)[1])
                    O3 = spzeros(np.shape(D21)[0], np.shape(D13)[1])

                    C = sp.vstack((sp.hstack((O1, -D32, D23)),
                                   sp.hstack((D31, O2, -D13)),
                                   sp.hstack((-D21, D12, O3))), format="csr")

                    self._edgeCurl = sdiag(1/S)*(C*sdiag(L))

            return self._edgeCurl
Example #20
0
        def fget(self):
            if(self._edgeCurl is None):
                assert self.dim > 1, "Edge Curl only programed for 2 or 3D."
                # The number of cell centers in each direction
                n = self.vnC

                # Compute lengths of cell edges
                L = self.edge

                # Compute areas of cell faces
                S = self.area

                # Compute divergence operator on faces
                if self.dim == 2:

                    D21 = sp.kron(ddx(n[1]), speye(n[0]))
                    D12 = sp.kron(speye(n[1]), ddx(n[0]))
                    C = sp.hstack((-D21, D12), format="csr")
                    self._edgeCurl = C*sdiag(1/S)

                elif self.dim == 3:

                    D32 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]+1))
                    D23 = kron3(speye(n[2]), ddx(n[1]), speye(n[0]+1))
                    D31 = kron3(ddx(n[2]), speye(n[1]+1), speye(n[0]))
                    D13 = kron3(speye(n[2]), speye(n[1]+1), ddx(n[0]))
                    D21 = kron3(speye(n[2]+1), ddx(n[1]), speye(n[0]))
                    D12 = kron3(speye(n[2]+1), speye(n[1]), ddx(n[0]))

                    O1 = spzeros(np.shape(D32)[0], np.shape(D31)[1])
                    O2 = spzeros(np.shape(D31)[0], np.shape(D32)[1])
                    O3 = spzeros(np.shape(D21)[0], np.shape(D13)[1])

                    C = sp.vstack((sp.hstack((O1, -D32, D23)),
                                   sp.hstack((D31, O2, -D13)),
                                   sp.hstack((-D21, D12, O3))), format="csr")

                    self._edgeCurl = sdiag(1/S)*(C*sdiag(L))

            return self._edgeCurl
Example #21
0
 def fget(self):
     if(self._nodalGrad is None):
         # The number of cell centers in each direction
         n = self.vnC
         # Compute divergence operator on faces
         if(self.dim == 1):
             G = ddx(n[0])
         elif(self.dim == 2):
             D1 = sp.kron(speye(n[1]+1), ddx(n[0]))
             D2 = sp.kron(ddx(n[1]), speye(n[0]+1))
             G = sp.vstack((D1, D2), format="csr")
         elif(self.dim == 3):
             D1 = kron3(speye(n[2]+1), speye(n[1]+1), ddx(n[0]))
             D2 = kron3(speye(n[2]+1), ddx(n[1]), speye(n[0]+1))
             D3 = kron3(ddx(n[2]), speye(n[1]+1), speye(n[0]+1))
             G = sp.vstack((D1, D2, D3), format="csr")
         # Compute lengths of cell edges
         L = self.edge
         self._nodalGrad = sdiag(1/L)*G
     return self._nodalGrad
Example #22
0
 def fget(self):
     if(self._nodalGrad is None):
         # The number of cell centers in each direction
         n = self.vnC
         # Compute divergence operator on faces
         if(self.dim == 1):
             G = ddx(n[0])
         elif(self.dim == 2):
             D1 = sp.kron(speye(n[1]+1), ddx(n[0]))
             D2 = sp.kron(ddx(n[1]), speye(n[0]+1))
             G = sp.vstack((D1, D2), format="csr")
         elif(self.dim == 3):
             D1 = kron3(speye(n[2]+1), speye(n[1]+1), ddx(n[0]))
             D2 = kron3(speye(n[2]+1), ddx(n[1]), speye(n[0]+1))
             D3 = kron3(ddx(n[2]), speye(n[1]+1), speye(n[0]+1))
             G = sp.vstack((D1, D2, D3), format="csr")
         # Compute lengths of cell edges
         L = self.edge
         self._nodalGrad = sdiag(1/L)*G
     return self._nodalGrad
Example #23
0
        def fget(self):
            if(self._faceDiv is None):
                # The number of cell centers in each direction
                n = self.vnC
                # Compute faceDivergence operator on faces
                if(self.dim == 1):
                    D = ddx(n[0])
                elif(self.dim == 2):
                    D1 = sp.kron(speye(n[1]), ddx(n[0]))
                    D2 = sp.kron(ddx(n[1]), speye(n[0]))
                    D = sp.hstack((D1, D2), format="csr")
                elif(self.dim == 3):
                    D1 = kron3(speye(n[2]), speye(n[1]), ddx(n[0]))
                    D2 = kron3(speye(n[2]), ddx(n[1]), speye(n[0]))
                    D3 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]))
                    D = sp.hstack((D1, D2, D3), format="csr")
                # Compute areas of cell faces & volumes
                S = self.area
                V = self.vol
                self._faceDiv = sdiag(1/V)*D*sdiag(S)

            return self._faceDiv
Example #24
0
        def fget(self):
            if(self._faceDiv is None):
                # The number of cell centers in each direction
                n = self.vnC
                # Compute faceDivergence operator on faces
                if(self.dim == 1):
                    D = ddx(n[0])
                elif(self.dim == 2):
                    D1 = sp.kron(speye(n[1]), ddx(n[0]))
                    D2 = sp.kron(ddx(n[1]), speye(n[0]))
                    D = sp.hstack((D1, D2), format="csr")
                elif(self.dim == 3):
                    D1 = kron3(speye(n[2]), speye(n[1]), ddx(n[0]))
                    D2 = kron3(speye(n[2]), ddx(n[1]), speye(n[0]))
                    D3 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]))
                    D = sp.hstack((D1, D2, D3), format="csr")
                # Compute areas of cell faces & volumes
                S = self.area
                V = self.vol
                self._faceDiv = sdiag(1/V)*D*sdiag(S)

            return self._faceDiv
Example #25
0
 def faceDiv(self):
     """
     Construct divergence operator (face-stg to cell-centres).
     """
     if getattr(self, '_faceDiv', None) is None:
         n = self.vnC
         # Compute faceDivergence operator on faces
         if(self.dim == 1):
             D = ddx(n[0])
         elif(self.dim == 2):
             D1 = sp.kron(speye(n[1]), ddx(n[0]))
             D2 = sp.kron(ddx(n[1]), speye(n[0]))
             D = sp.hstack((D1, D2), format="csr")
         elif(self.dim == 3):
             D1 = kron3(speye(n[2]), speye(n[1]), ddx(n[0]))
             D2 = kron3(speye(n[2]), ddx(n[1]), speye(n[0]))
             D3 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]))
             D = sp.hstack((D1, D2, D3), format="csr")
         # Compute areas of cell faces & volumes
         S = self.area
         V = self.vol
         self._faceDiv = sdiag(1/V)*D*sdiag(S)
     return self._faceDiv
Example #26
0
 def faceDiv(self):
     """
     Construct divergence operator (face-stg to cell-centres).
     """
     if getattr(self, '_faceDiv', None) is None:
         n = self.vnC
         # Compute faceDivergence operator on faces
         if (self.dim == 1):
             D = ddx(n[0])
         elif (self.dim == 2):
             D1 = sp.kron(speye(n[1]), ddx(n[0]))
             D2 = sp.kron(ddx(n[1]), speye(n[0]))
             D = sp.hstack((D1, D2), format="csr")
         elif (self.dim == 3):
             D1 = kron3(speye(n[2]), speye(n[1]), ddx(n[0]))
             D2 = kron3(speye(n[2]), ddx(n[1]), speye(n[0]))
             D3 = kron3(ddx(n[2]), speye(n[1]), speye(n[0]))
             D = sp.hstack((D1, D2, D3), format="csr")
         # Compute areas of cell faces & volumes
         S = self.area
         V = self.vol
         self._faceDiv = sdiag(1 / V) * D * sdiag(S)
     return self._faceDiv