Пример #1
0
    def computeJacobian(self):
        """ Compute the global Jacobian """

        self.nJ = PUBSlib.computejnnz(self.nsurf,self.nedge,self.ngroup,self.nvert,self.surf_edge,self.edge_group,self.group_k,self.group_n,self.edge_count)
        Ja, Ji, Jj = PUBSlib.computejacobian(self.nJ, self.nT, self.nD, self.nsurf, self.nedge, self.ngroup, self.nvert, self.surf_vert, self.surf_edge, self.edge_group, self.group_k, self.group_m, self.group_n, self.group_d, self.surf_index_P, self.edge_index_P, self.surf_index_C, self.edge_index_C, self.knot_index, self.edge_count, self.T)
        self.J = scipy.sparse.csc_matrix((Ja,(Ji,Jj)))

        self.Nuv = PUBSlib.getsurfacesizes(self.nsurf, self.nedge, self.ngroup, self.surf_edge, self.edge_group, self.group_n)
        self.Np0 = numpy.zeros(self.nsurf+1)
        for s in range(self.nsurf+1):
            self.Np0[s] = int(sum(self.Nuv[:s,0]*self.Nuv[:s,1]))
        surf = numpy.zeros(self.Np0[-1],int)
        u = numpy.zeros(self.Np0[-1])
        v = numpy.zeros(self.Np0[-1])
        for s in range(self.nsurf):
            T = PUBSlib.getsurfacet(s+1, self.Nuv[s,0], self.Nuv[s,1], self.nT, self.nsurf, self.nedge, self.surf_edge, self.surf_index_P, self.edge_index_P, self.T)
            surf[self.Np0[s]:self.Np0[s+1]] = s
            u[self.Np0[s]:self.Np0[s+1]] = T[:,:,0].flatten(order='F')
            v[self.Np0[s]:self.Np0[s+1]] = T[:,:,1].flatten(order='F')
        self.J0 = self.evaluateBases(surf, u, v, 0, 0)
        self.Ju = self.evaluateBases(surf, u, v, 1, 0)
        self.Jv = self.evaluateBases(surf, u, v, 0, 1)

        self.nM = PUBSlib.computemnnz(self.nsurf,self.nedge,self.ngroup,self.nvert,self.surf_edge,self.edge_group,self.group_m,self.surf_index_C, self.edge_index_Q, self.vert_index_Q, self.edge_count, self.surf_c1, self.edge_c1)
        Ma, Mi, Mj = PUBSlib.computedofmapping(self.nM,self.nsurf,self.nedge,self.ngroup,self.nvert,self.surf_vert,self.surf_edge,self.edge_group,self.group_m,self.surf_index_C,self.edge_index_C,self.edge_index_Q,self.vert_index_Q, self.edge_count,self.surf_c1,self.edge_c1)
        self.M = scipy.sparse.csc_matrix((Ma,(Mi,Mj)))
        self.JM = self.J.dot(self.M)

        if self.printInfo:
            print '# Jacobian non-zeros =',self.JM.nnz
Пример #2
0
    def computeJacobian(self):
        """ Compute the global Jacobian """

        self.nJ = PUBSlib.computejnnz(self.nsurf, self.nedge, self.ngroup,
                                      self.nvert, self.surf_edge,
                                      self.edge_group, self.group_k,
                                      self.group_n, self.edge_count)
        Ja, Ji, Jj = PUBSlib.computejacobian(
            self.nJ, self.nT, self.nD, self.nsurf, self.nedge, self.ngroup,
            self.nvert, self.surf_vert, self.surf_edge, self.edge_group,
            self.group_k, self.group_m, self.group_n, self.group_d,
            self.surf_index_P, self.edge_index_P, self.surf_index_C,
            self.edge_index_C, self.knot_index, self.edge_count, self.T)
        self.J = scipy.sparse.csc_matrix((Ja, (Ji, Jj)))

        self.Nuv = PUBSlib.getsurfacesizes(self.nsurf, self.nedge, self.ngroup,
                                           self.surf_edge, self.edge_group,
                                           self.group_n)
        self.Np0 = numpy.zeros(self.nsurf + 1)
        for s in range(self.nsurf + 1):
            self.Np0[s] = int(sum(self.Nuv[:s, 0] * self.Nuv[:s, 1]))
        surf = numpy.zeros(self.Np0[-1], int)
        u = numpy.zeros(self.Np0[-1])
        v = numpy.zeros(self.Np0[-1])
        for s in range(self.nsurf):
            T = PUBSlib.getsurfacet(s + 1, self.Nuv[s, 0], self.Nuv[s, 1],
                                    self.nT, self.nsurf, self.nedge,
                                    self.surf_edge, self.surf_index_P,
                                    self.edge_index_P, self.T)
            surf[self.Np0[s]:self.Np0[s + 1]] = s
            u[self.Np0[s]:self.Np0[s + 1]] = T[:, :, 0].flatten(order='F')
            v[self.Np0[s]:self.Np0[s + 1]] = T[:, :, 1].flatten(order='F')
        self.J0 = self.evaluateBases(surf, u, v, 0, 0)
        self.Ju = self.evaluateBases(surf, u, v, 1, 0)
        self.Jv = self.evaluateBases(surf, u, v, 0, 1)

        self.nM = PUBSlib.computemnnz(self.nsurf, self.nedge, self.ngroup,
                                      self.nvert, self.surf_edge,
                                      self.edge_group, self.group_m,
                                      self.surf_index_C, self.edge_index_Q,
                                      self.vert_index_Q, self.edge_count,
                                      self.surf_c1, self.edge_c1)
        Ma, Mi, Mj = PUBSlib.computedofmapping(
            self.nM, self.nsurf, self.nedge, self.ngroup, self.nvert,
            self.surf_vert, self.surf_edge, self.edge_group, self.group_m,
            self.surf_index_C, self.edge_index_C, self.edge_index_Q,
            self.vert_index_Q, self.edge_count, self.surf_c1, self.edge_c1)
        self.M = scipy.sparse.csc_matrix((Ma, (Mi, Mj)))
        self.JM = self.J.dot(self.M)

        if self.printInfo:
            print '# Jacobian non-zeros =', self.JM.nnz