def local_mass_matrix_tri(tri,xu_l,yu_l,xs_l,ys_l): # tri = numpy array shape (3,2) # giving the triangle coords tri = np.hstack([tri,np.ones((3,1))]).transpose() #area = np.linalg.det(tri)/2 tri = np.dot(tri,bari_coords) eval_p = np.dot(np.matlib.eye(2,3),tri).transpose() (dx,dy,phi_u,omega) = basis.tri_p1(xu_l,yu_l,eval_p) (dx,dy,psi_s,omega) = basis.tri_p1(xs_l,ys_l,eval_p) lm = np.zeros((3,3)) for i in np.arange(0,3): col = np.reshape(phi_u[i,:],(3,1)) row = np.reshape(psi_s[i,:],(1,3)) lm += omega/3*np.dot(col,row) return lm
def calc_gradu_gradv_p1_ieq_partly(topo,x,y,ieq): ndofs = max(ieq)+1 (rows,cols)= la_utils.get_sparsity_pattern_ieq(topo,ieq) values = np.zeros(rows.shape) for row in topo: x_l = x[row] y_l = y[row] eval_points = np.zeros((0,2)) (phi_dx,phi_dy,phi,omega) = basis.tri_p1(x_l,y_l,eval_points) dx_j = phi_dx dx_i = phi_dx.transpose() dy_j = phi_dy dy_i = phi_dy.transpose() entries = ieq[row] #print x_l #print y_l #print row #print entries local_matrix = omega*(np.dot(dx_i,dx_j)+np.dot(dy_i,dy_j)) values = la_utils.add_local_to_global_coo(rows,cols,values, entries,entries,local_matrix) A = sparse.coo_matrix((values,(rows,cols)),shape=(ndofs,ndofs)) A.tocsr() return A
def calc_gradu_gradv_p1_partly(topo,x,y): """ Assembling the Laplace operator. The function name resambles the operator gradtient of the trial functionctions, multiplied the gradient of the test functions. Assuming :math:`P_1` elements on the :math:`K` trinagle we have: .. math:: \int_K \mathrm{grad}(u)_j \cdot \mathrm{grad}(v)_i = \mathrm{Area}(K)\ \mathrm{grad}(u_j) \cdot \mathrm{grad}(v_i) In the code snippet, we can see that, by default, derivatives are represented a 1x3 row. The ``dx_i`` and ``dy_i`` components are transpose. So we only need the matrix product ``np.dot`` to have the local stffness matrix. The values for thederivatives are obtained form the ``tri_p1`` function in the `basis_func` module, `check its documentation`_. .. _check its documentation: ./basis_func.html .. code:: python dx_j = phi_dx dx_i = phi_dx.transpose() dy_j = phi_dy dy_i = phi_dy.transpose() local_matrix = omega*(np.dot(dx_i,dx_j)+np.dot(dy_i,dy_j)) Input: ``x``, ``y``, ``topo`` : the nodes coordinates and the connectivity. Output: ``A`` : The spasre matrix A representing the discretized operator.\n """ ndofs = max(x.shape) (rows,cols)= la_utils.get_sparsity_pattern(topo) values = np.zeros(rows.shape) for row in topo: x_l = x[row] y_l = y[row] eval_points = np.zeros((0,2)) (phi_dx,phi_dy,phi,omega) = basis.tri_p1(x_l,y_l,eval_points) dx_j = phi_dx dx_i = phi_dx.transpose() dy_j = phi_dy dy_i = phi_dy.transpose() local_matrix = omega*(np.dot(dx_i,dx_j)+np.dot(dy_i,dy_j)) values = la_utils.add_local_to_global_coo(rows,cols,values, row,row,local_matrix) A = sparse.coo_matrix((values,(rows,cols)),shape=(ndofs,ndofs)) #plt.spy(A) #plt.show() A.tocsr() return A
def u_v_p1_inv_diag(topo,x,y): ndofs = max(x.shape) A = sparse.csr_matrix((ndofs,ndofs)) for row in topo: x_l = x[row] y_l = y[row] #local_matrix = local_p1_p1_mass_tri(x_l,y_l) eval_points = np.zeros((0,2)) (phi_dx,phi_dy,phi,omega) = basis.tri_p1(x_l,y_l,eval_points) local_matrix = omega/3. * np.eye(3) [r,c] = np.meshgrid(row,row) r = np.concatenate(r) c = np.concatenate(c) vals = np.concatenate(local_matrix) tmp = sparse.coo_matrix((vals, (r,c)), shape=(ndofs,ndofs)) A = A+tmp vals = A.data vals = np.power(vals,-1) (rows,cols) = A.nonzero() A = sparse.coo_matrix((vals, (rows,cols)), shape=(ndofs,ndofs)) return A
def divu_p_p1_iso_p2_p1(topo_p,x_p,y_p, topo_u,x_u,y_u,c2f): ndofs_u = max(x_u.shape) ndofs_p = max(x_p.shape) B1 = sparse.csr_matrix((ndofs_u,ndofs_p)) B2 = sparse.csr_matrix((ndofs_u,ndofs_p)) el_id = 0 for nd_p in topo_p: #print("====================") #print nd_p fine_els = c2f[el_id,:] x_lp = x_p[nd_p] y_lp = y_p[nd_p] local_matrix = np.zeros((3,3)) for el in fine_els: nd_u = topo_u[el,:] x_lu = x_u[nd_u] y_lu = y_u[nd_u] eval_p = np.zeros( (3,2) ) eval_p[:,0] = x_lu.transpose() eval_p[:,1] = y_lu.transpose() (u_dx,u_dy,u,omega_u) = basis.tri_p1(x_lu,y_lu,eval_p) (p_dx,p_dy,p,omega_p) = basis.tri_p1(x_lp,y_lp,eval_p) #print("--------------------") #print nd_u #print u_dx int_q_omega = np.zeros((1,3)) #print sum(p[:,0]) for k in range(0,3): int_q_omega[0,k] += omega_u/3 * sum(p[:,k]) #print 12*int_q_omega local_matrix = np.dot(u_dx.transpose(), int_q_omega) #print local_matrix B1 = la_utils.add_local_to_global(B1,local_matrix,nd_u,nd_p) local_matrix = np.dot(u_dy.transpose(), int_q_omega) B2 = la_utils.add_local_to_global(B2,local_matrix,nd_u,nd_p) #print B1.todense() el_id += 1 return B1, B2
def local_fluid_str_coupling(tri,xu_l,yu_l,s_l,t_l,tri_map): # tri = numpy array shape (3,2) # giving the triangle coords tri = np.hstack([tri,np.ones((3,1))]).transpose() #print '***' tri_ref = np.dot(tri_map,tri) area = np.linalg.det(tri_ref)/2 #print tri_ref tri = np.dot(tri,bari_coords) eval_p = np.dot(np.eye(2,3),tri).transpose() (dx,dy,phi_u,omega) = basis.tri_p1(xu_l,yu_l,eval_p) eval_p = np.hstack([eval_p,np.ones((3,1))]).transpose() eval_p = np.dot(tri_map,eval_p) eval_p = eval_p[0:2,:].transpose() #print eval_p.shape (dx,dy,psi_s,omega) = basis.tri_p1(s_l,t_l,eval_p) lm = np.zeros((3,3)) for i in np.arange(0,3): col = np.reshape(phi_u[i,:],(3,1)) row = np.reshape(psi_s[i,:],(1,3)) lm += area/3*np.dot(col,row) return lm
def local_p1_p1_mass_tri(x_l,y_l): eval_p = np.vstack([ np.reshape(x_l,(1,3)), np.reshape(y_l,(1,3)), np.ones((1,3))]) eval_p = np.dot(eval_p,bari_coords) eval_p = eval_p[0:2,:].transpose() (dx,dy,phi,omega) = basis.tri_p1(x_l,y_l,eval_p) lm = np.zeros((3,3)) for i in np.arange(0,3): col = np.reshape(phi[i,:],(3,1)) row = np.reshape(phi[i,:],(1,3)) lm += omega/3*np.dot(col,row) return lm
def diagonal_mass_matrix(topo_s,s_lgr,t_lgr): ndofs = s_lgr.shape[0] entries = np.zeros((ndofs)) for row in topo_s: x_l = s_lgr[row] y_l = t_lgr[row] eval_points = np.zeros((0,2)) (phi_dx,phi_dy,phi,omega) = basis.tri_p1(x_l,y_l,eval_points) entries[row] += omega/3. #print omega rows = np.arange(0,s_lgr.shape[0]) M = sparse.coo_matrix((entries, (rows,rows)), shape=(ndofs,ndofs)) return M
def calc_u_gradv_w_p1_partly(topo, x, y, u_x, u_y): ndofs = max(x.shape) u_x = np.reshape(u_x, (ndofs, 1)) u_y = np.reshape(u_y, (ndofs, 1)) A11 = sparse.csr_matrix((ndofs,ndofs)) for row in topo: x_l = x[row] y_l = y[row] local_matrix = np.zeros((3,3)) local_mass_matrix = local_p1_p1_mass_tri(x_l,y_l) eval_points = np.zeros( (3,2) ) eval_points[:,0] = x_l.transpose() eval_points[:,1] = y_l.transpose() (v_dx,v_dy,v_l,omega_v) = basis.tri_p1(x_l,y_l,eval_points) # local_matrix = np.reshape(np.dot(u_x[row].transpose(), local_mass_matrix), (1,3)) # local_matrix = np.dot(v_dx.transpose(), local_matrix) # A11 = la_utils.add_local_to_global(A11,local_matrix,row,row) # # local_matrix = np.reshape(np.dot(u_y[row].transpose(), local_mass_matrix), (1,3)) # local_matrix = np.dot(v_dy.transpose(), local_matrix) # A11 = la_utils.add_local_to_global(A11,local_matrix,row,row) local_matrix = np.dot(local_mass_matrix, u_x[row]) local_matrix = np.dot(local_matrix, v_dx) A11 = la_utils.add_local_to_global(A11,local_matrix,row,row) local_matrix = np.dot(local_mass_matrix, u_y[row]) local_matrix = np.dot(local_matrix, v_dy) A11 = la_utils.add_local_to_global(A11,local_matrix,row,row) # local_matrix = np.reshape(np.dot(u_x[row].transpose(), local_mass_matrix), (1,3)) # local_matrix = np.dot(v_dx.transpose(), local_matrix) # A22 = la_utils.add_local_to_global(A22,local_matrix,row,row) # # local_matrix = np.reshape(np.dot(u_y[row].transpose(), local_mass_matrix), (1,3)) # local_matrix = np.dot(v_dy.transpose(), local_matrix) # A22 = la_utils.add_local_to_global(A22,local_matrix,row,row) return A11
def ibm_force(XY_str,s_lgr,topo_u,x_u,y_u,point_in_tri): node_s = XY_str.shape[0] force_x = np.zeros((x_u.shape[0],1)) force_y = np.zeros((x_u.shape[0],1)) Xs = XY_str[:,0] Ys = XY_str[:,1] for cnt in range(0,node_s): if cnt == 0: backward = node_s-1 middle = cnt forward = cnt+1 ds = s_lgr[forward]-s_lgr[middle] if cnt == node_s-1: backward = cnt-1 middle = cnt forward = 0 ds = s_lgr[middle]-s_lgr[backward] else: backward = cnt-1 middle = cnt forward = cnt+1 ds = s_lgr[forward]-s_lgr[middle] Ds_X1 = (Xs[forward] - Xs[middle])/ds Ds_X0 = (Xs[middle] - Xs[backward])/ds Ds_Y1 = (Ys[forward] - Ys[middle])/ds Ds_Y0 = (Ys[middle] - Ys[backward])/ds stiff_x = Ds_X1-Ds_X0 stiff_y = Ds_Y1-Ds_Y0 nds = topo_u[point_in_tri[cnt]] x_l = x_u[nds] y_l = y_u[nds] eval_p = np.zeros((1,2)) eval_p[0,:] = XY_str[cnt,:] (phi_dx,phi_dy,phi,omega) = basis.tri_p1(x_l,y_l,eval_p) force_x[nds] += stiff_x * phi.transpose() force_y[nds] += stiff_y * phi.transpose() return force_x, force_y
def u_s_p1(topo_u,x_u,y_u, topo_s,x_s,y_s,s_lgr,ieq_s, str_segments,fluid_id): r = max(ieq_s)+1 #print r GT = sparse.csr_matrix((x_u.shape[0],r[0])) str_iel = 0 for str_el in str_segments: s_dofs = ieq_s[topo_s[str_iel,:]] s_l = s_lgr[topo_s[str_iel,:]] el_list = fluid_id[str_iel] #print '=================' #print s_l #print el_list iel = 0 for segment in str_el: f_id = el_list[iel] u_dofs = topo_u[f_id,:] l = list(segment.coords) sp = geom.get_reference_coords(topo_s,x_s,y_s,s_lgr,str_iel,l) (ds_psi,psi,omega) = basis.lin_p1(s_l,sp) x_ul = x_u[topo_u[f_id,:]] y_ul = y_u[topo_u[f_id,:]] p0 = Point(l[0]) p1 = Point(l[1]) eval_p = np.zeros((2,2)) eval_p[0,0] = p0.x eval_p[0,1] = p0.y eval_p[1,0] = p1.x eval_p[1,1] = p1.y (phi_dx,phi_dy,phi,omega) = basis.tri_p1(x_ul,y_ul,eval_p) #print '-----------------' #print f_id #print s_dofs #print u_dofs #print sp #print psi for i in range(0,2):#loop over quadrature points cln = np.zeros((3,1)) row = np.zeros((1,2)) cln[:,0] = phi[i,:] row[0,:] = psi[i,:] local_matrix = .5 * segment.length * np.dot(cln,row) GT = la_utils.add_local_to_global(GT,local_matrix,u_dofs,s_dofs) #print '***' #print row #print cln #print local_matrix*8 #print '***' # #print segment.length #print x_ul #print f_id #print psi #print phi iel += 1 # str_iel+=1 #break return GT
A11 = assemble.gradu_gradv_p1(topo_u, x_u, y_u) M22 = M11 (BT1, BT2) = assemble.divu_p_p1_iso_p2_p1p0(topo_p, x_p, y_p, topo_u, x_u, y_u, c2f) # (BT1,BT2) = assemble.divu_p_p1_iso_p2_p1(topo_p,x_p,y_p, # topo_u,x_u,y_u,c2f) BT = sparse.vstack([BT1, BT2]) B = BT.transpose() mean_p = np.zeros((1, ndofs_p)) for row in topo_p: x_l = x_p[row[0:3]] y_l = y_p[row[0:3]] eval_p = np.zeros((0, 2)) (phi_dx, phi_dy, phi, omega) = shp.tri_p1(x_l, y_l, eval_p) mean_p[0, row] += omega * np.array([1. / 3., 1. / 3., 1. / 3., 1]) # mean_p[0,row] += omega * np.array([1./3.,1./3.,1./3.]) mean_pT = mean_p.transpose() #upper boundary bc_id = np.where(y_u > y_top - delta_x / 10) BT1 = la_utils.clear_rows(BT1, bc_id) BT2 = la_utils.clear_rows(BT2, bc_id) #lower boundary bc_id = np.where(y_u < y_bottom + delta_x / 10) BT1 = la_utils.clear_rows(BT1, bc_id) BT2 = la_utils.clear_rows(BT2, bc_id)
def err_l2(topo, x, y, sol): aq = np.array([ 1. / 90., 1. / 90., 1. / 90., 16. / 225., 16. / 225., 16. / 225., (49. / 120.)**2, (49. / 120.)**2, (49. / 120.)**2, 81. / 320. ]) # pesi quadratura xq = np.array( [0., 1., 0., 0.5, 0.5, 0., 1. / 7., 5. / 7., 1. / 7., 1. / 3.]) # coord x nodi quadratura riferimento yq = np.array( [0., 0., 1., 0., 0.5, 0.5, 5. / 7., 1. / 7., 1. / 7., 1. / 3.]) # coord y nodi quadratura riferimento # eval_p = np.array([xq,yq]) # eval_p = np.reshape ( eval_p, (xq.shape[0],2)) er_l2 = 0. ex_l2 = 0. er_derx = 0. ex_derx = 0. er_dery = 0. ex_dery = 0. for row in topo: A = x[row] B = y[row] uu = sol[row] b11 = A[1] - A[0] b12 = A[2] - A[0] b21 = B[1] - B[0] b22 = B[2] - B[0] #det=b11*b22-b12*b21 xp = A[0] + b11 * xq + b12 * yq yp = B[0] + b21 * xq + b22 * yq eval_p = np.array([xp, yp]) eval_p = eval_p.transpose() #eval_p = eval_p.transpose # print eval_p.shape[0] tmpesatta = esatta.sol_esatta1(xp, yp) tmpesatta = np.reshape(tmpesatta, (1, xp.shape[0])) # tmpderx = esatta.dx_sol_esatta(xp,yp) (tmpderx, tmpdery) = esatta.der_sol_esatta_1(xp, yp) # print "ciao",tmpderx # tmpderx = np.reshape ( tmpderx, (1,xp.shape[0])) # tmpdery = esatta.dy_sol_esatta(xp,yp) # print "ciao-ciao", tmpdery # tmpdery = np.reshape (tmpdery , (1,xp.shape[0])) tmpapprox = np.zeros((1, xp.shape[0])) tmphderx = np.zeros((1, xp.shape[0])) tmphdery = np.zeros((1, xp.shape[0])) (phi_dx, phi_dy, phi, omega) = basis.tri_p1(A, B, eval_p) #print phi for i in np.array([0, 1, 2]): tmpapprox = tmpapprox + uu[i] * phi[:, i] tmphderx = tmphderx + uu[i] * phi_dx[:, i] tmphdery = tmphdery + uu[i] * phi_dy[:, i] tmp = np.sum(aq * (tmpesatta - tmpapprox)**2) * 2 * omega tmp2 = np.sum(aq * (tmpesatta)**2) * 2 * omega tmpx = np.sum(aq * (tmpderx - tmphderx)**2) * 2 * omega tmp2x = np.sum(aq * tmpderx**2) * 2 * omega tmpy = np.sum(aq * (tmpdery - tmphdery)**2) * 2 * omega tmp2y = np.sum(aq * tmpdery**2) * 2 * omega er_derx = er_derx + tmpx ex_derx = ex_derx + tmp2x er_dery = er_dery + tmpy ex_dery = ex_dery + tmp2y er_l2 = er_l2 + tmp ex_l2 = ex_l2 + tmp2 er_l2 = np.sqrt(er_l2 / ex_l2) er_derx = np.sqrt(er_derx / ex_derx) er_dery = np.sqrt(er_dery / ex_dery) return er_l2, er_derx, er_dery