예제 #1
0
def main(msh,n):
    p,t,be=mesh.read_gmsh(msh)
    h=mesh.max_mesh_width(p,t)
    IN=fem.interiorNodes(p,t,be)
    S=fem.stiffness(p,t)          
    M=fem.mass(p,t)
    L=fem.load(p,t,n,lambda x,y:1)
    S=S.tocsr()
    M=M.tocsr()
    L=L.tocsr()
    
    #neumannnodes
    N=np.zeros(len(p))
    j=0
    for i in range (0,len(p)):
        if (p[i,0]==-1 or p[i,0]==1):
            if 1>p[i,1] and p[i,1]>=0:
                N[j]=i
                j=j+1
        if p[i,1]==1:
            N[j]=i
            j=j+1
    j=j-1 #number of neumannnodes

    Sr=sp.csr_matrix((len(IN)+j,len(IN)+j)) #adjusting solution to boundary condition
    Mr=sp.csr_matrix((len(IN)+j,len(IN)+j))
    Lr=sp.csr_matrix((len(IN)+j,1))
    A=sp.csr_matrix((len(IN)+j,len(p)))
    for i in range(0,len(IN)):
        A[i,IN[i]]=1
        
    for i in range(0,j):
        A[i+len(IN),N[i]]=1
    Sr=A*S*A.transpose()
    Mr=A*M*A.transpose()
    Lr=A*L
    un=spla.spsolve(Sr+Mr,Lr) 
    u1=A.transpose()*un
    fem.plot(p,t,u1)
예제 #2
0
def no_homogen(h0,f,n,g):
	# First lets generate the mesh for the unite circle
	mesh_gen(h0)
	mesh=msh.read_gmsh('circle.msh')
	# Matrix of nodes
	p=mesh[0]
	# Matrix of triangles index
	t=mesh[1]
	# Matrix of boundary edges 
	be=mesh[2]
	# Now lets compute the stiffness matrix
	A=fem.stiffness(p,t)
	# Lets compute the load vector
	Load=fem.load(p,t,n,f)
	# Lets compute the load neumann vector
	Loadneumann=fem.loadNeumann(p,be,n,g)
	#Finally the Loadvector will be the sum of the one with the source f
	# and the one with f
	Load=Load+Loadneumann
	# Lets compute the vector m that analogous to the load vector
	# with f(x.y)=1
	m=fem.load(p,t,n,lambda x,y:1)
	# Lets create the matrix and vectors of the modified bigger system to
	# solve with lagrangian multipliers of size (size(A)+(1,1))
	size=A.shape[0]
	B=sparse.lil_matrix(np.zeros([size+1,size+1]))
	B[0:size,0:size]=A
	B[0:size,size]=m
	B[size,0:size]=m.transpose()
	# We add a zero at the end of f 
	Load=np.concatenate((Load,np.array([[0]])))
	# Now lets get the solution of the linear system using spsolve function
	U=spla.spsolve(B,Load)
	u=U[0:size]
	l=U[size]
	return [p,t,u,l]
예제 #3
0
def no_homogen(h0, f, n, g):
    # First lets generate the mesh for the unite circle
    mesh_gen(h0)
    mesh = msh.read_gmsh('circle.msh')
    # Matrix of nodes
    p = mesh[0]
    # Matrix of triangles index
    t = mesh[1]
    # Matrix of boundary edges
    be = mesh[2]
    # Now lets compute the stiffness matrix
    A = fem.stiffness(p, t)
    # Lets compute the load vector
    Load = fem.load(p, t, n, f)
    # Lets compute the load neumann vector
    Loadneumann = fem.loadNeumann(p, be, n, g)
    #Finally the Loadvector will be the sum of the one with the source f
    # and the one with f
    Load = Load + Loadneumann
    # Lets compute the vector m that analogous to the load vector
    # with f(x.y)=1
    m = fem.load(p, t, n, lambda x, y: 1)
    # Lets create the matrix and vectors of the modified bigger system to
    # solve with lagrangian multipliers of size (size(A)+(1,1))
    size = A.shape[0]
    B = sparse.lil_matrix(np.zeros([size + 1, size + 1]))
    B[0:size, 0:size] = A
    B[0:size, size] = m
    B[size, 0:size] = m.transpose()
    # We add a zero at the end of f
    Load = np.concatenate((Load, np.array([[0]])))
    # Now lets get the solution of the linear system using spsolve function
    U = spla.spsolve(B, Load)
    u = U[0:size]
    l = U[size]
    return [p, t, u, l]
예제 #4
0
###                                                           ###
###             Script that Produces the plots                ###
###                  in 3f) and 3h)                           ###
###                                                           ###
###-----------------------------------------------------------###

# First call the module meshes.py

import meshes as msh
import numpy as np
import matplotlib.pyplot as plt

# Get the p and t arrays for the file of unstructured mesh of the square
# generated by gmsh
file = 'square_mesh.msh'
mesh1 = msh.read_gmsh(file)
p1 = mesh1[0]
t1 = mesh1[1]
#Name of the file of the output plot
file = 'unstructured.png'
title = 'Unstructured mesh'
msh.show(p1, t1, file, title)

# Get the p and t arrays for the regular mesh of the square of side 1
# For structured meshes the value of h0 is not arbitrary, as it has to fit
# a integer number of 1-dimensional elements in each border, the closest
# h0 to 0.01 that fullfill that is h0=np.sqrt(2)/14=0.10101....
a = 1
h0 = np.sqrt(2) / 14
mesh2 = msh.grid_square(a, h0)
p2 = mesh2[0]
예제 #5
0
def main():
  
  lu = 1.548888;                               # value of l(sol)
  f   = lambda x, y: (1.0);

  Nspacings = 9;                  # number of mesh widths to test (in powers of sqrt(2))           -> CHANGE BACK TO 10!!!!
  h0 = 0.3;                       # maximum value of mesh width
  h = [None]*Nspacings;           # vector for mesh widths (set values)
  dof = np.zeros(Nspacings);      # vector for mesh widths (true values)
  dof_reg = np.zeros(Nspacings);      # vector for mesh widths (true values)
  discret_err_bgm = [None]*Nspacings;     # vector for discretization errors for linear FEM
  discret_err_reg = [None]*Nspacings;    # vector for discretization errors for quadratic FEM

  # regular mesh
  for j in range(Nspacings):
    
    h = h0*2.0**(-j/2.0);
    [p, t, be, bd]=msh.create_msh("regular", h)
    
    # LINEAR FINITE ELEMENTS
    # Compute the discretized system:
    A_lin = FEM.stiffness(p, t);          # stiffness-matrix
    F_lin = FEM.load(p, t, 3, f);         # load-vector
    
    # degrees of freedom
    dof_reg[j] = p.shape[0]


    # solve system with Dirichtlet boundary conditions
    u_n = FEM.solve_d0(p, t, bd, A_lin, F_lin)

    # LINEAR FINITE ELEMENTS
    lun_lin = np.dot(u_n,F_lin);      # value of l(u_n)
    en_lin = lu-sqrt(abs(lun_lin));          # energy norm of error vector
    discret_err_reg[j] = en_lin;

  print 
  print "energy error with the regular mesh"
  print discret_err_reg

  # background mesh 
  for j in range(Nspacings):

    #[p, t, be, bd]=msh.create_msh_bgm("bgmesh"+str(j))
    [p, t, be, bd]=msh.read_gmsh("bgmesh"+str(j)+".msh")
    
    # LINEAR FINITE ELEMENTS
    # Compute the discretized system:
    A_lin = FEM.stiffness(p, t);          # stiffness-matrix
    F_lin = FEM.load(p, t, 3, f);         # load-vector
    
    # degrees of freedom
    dof[j] = p.shape[0]

    # solve system with Dirichtlet boundary conditions
    u_n = FEM.solve_d0(p, t, bd, A_lin, F_lin)

    # LINEAR FINITE ELEMENTS
    lun_lin = np.dot(u_n,F_lin);      # value of l(u_n)
    en_lin = lu-sqrt(abs(lun_lin));          # energy norm of error vector
    discret_err_bgm[j] = en_lin;

  print 
  print "energy error with the background mesh"
  print discret_err_bgm

  # ploting energy error distribution
  plt.loglog(dof_reg, discret_err_reg,':*', label='energy error - regular mesh')
  plt.loglog(dof, discret_err_bgm,':*', label='energy error - bgm')
  plt.title('energy error depending on degrees of freedom')
  plt.legend(loc=1)
  plt.show()

  # Visualization of the solution
  FEM.plot(p, t, u_n);             # approximated solution
  plt.show()
예제 #6
0
###                                                           ###
###             Script that Produces the plots                ###
###                  in 3f) and 3h)                           ###
###                                                           ###
###-----------------------------------------------------------###

# First call the module meshes.py

import meshes as msh
import numpy as np 
import matplotlib.pyplot as plt

# Get the p and t arrays for the file of unstructured mesh of the square
# generated by gmsh
file='square_mesh.msh'
mesh1=msh.read_gmsh(file)
p1=mesh1[0]
t1=mesh1[1]
#Name of the file of the output plot 
file='unstructured.png'
title='Unstructured mesh'
msh.show(p1,t1,file,title)

# Get the p and t arrays for the regular mesh of the square of side 1
# For structured meshes the value of h0 is not arbitrary, as it has to fit
# a integer number of 1-dimensional elements in each border, the closest 
# h0 to 0.01 that fullfill that is h0=np.sqrt(2)/14=0.10101....
a=1
h0=np.sqrt(2)/14
mesh2=msh.grid_square(a,h0)
p2=mesh2[0]
예제 #7
0
import meshes as mesh
import FEM as fem
import scipy.sparse as sp
import numpy as np
import scipy.sparse.linalg as spla
print('comparing mesh sizes (4a)')
p,t,be=mesh.read_gmsh('bgmesh0.msh')
print(len(p))
p,t,be=mesh.read_gmsh('bgmesh1.msh')
print(len(p))


def main(msh,n):
    p,t,be=mesh.read_gmsh(msh)
    h=mesh.max_mesh_width(p,t)
    IN=fem.interiorNodes(p,t,be)
    S=fem.stiffness(p,t)          
    M=fem.mass(p,t)
    L=fem.load(p,t,n,lambda x,y:1)
    S=S.tocsr()
    M=M.tocsr()
    L=L.tocsr()
    
    #neumannnodes
    N=np.zeros(len(p))
    j=0
    for i in range (0,len(p)):
        if (p[i,0]==-1 or p[i,0]==1):
            if 1>p[i,1] and p[i,1]>=0:
                N[j]=i
                j=j+1