def solve(self, method):
util.tic()
if method==1:
print("Gaussian elimination")
self.u = self.gaussian_el(self.sys, self.b)
else:
print("Numpy inverse matrix")
self.u = np.linalg.inv(self.sys).dot(self.b)
util.toc("Solved the equation: %0.2f s")
def draw_old(self):
util.tic()
x=[]
y=[]
z=[]
for node in self.mesh.nodes:
x.append(node.x)
y.append(node.y)
z.append(self.u[node.nr])
plt.scatter(x, y, z, zorder=3)
util.toc("Drawing solution: %.2f s")
def draw(self, nodes_or_mesh):
util.tic()
if nodes_or_mesh:
x = []
y = []
for node in self.nodes:
x.append(node.x)
y.append(node.y)
plt.scatter(x, y, 3, zorder=2)
else:
for el in self.elements:
el.draw()
util.toc("Drawing mesh: %.2f s")
def init_system_mat(self, is_axisym):
util.tic()
num_nodes = len(self.mesh.nodes)
self.sys = np.zeros((num_nodes, num_nodes)) # SYSTEM MATRIX
for el in self.mesh.elements:
if is_axisym:
k = self.element_mat_axisym(el)
else:
k = self.element_mat(el)
for i in range(len(el.nodes)):
for j in range(len(el.nodes)):
nr1 = el.nodes[i].nr
nr2 = el.nodes[j].nr
self.sys[nr1, nr2] = self.sys[nr1, nr2] + k[i,j]
util.toc("Created the system matrix: %0.2f s")
print("System matrix memory:", self.sys.nbytes, "bytes")
print("Shape of the matrix:", self.sys.shape)
def generate_mesh(self):
util.tic()
node_nr = 0
for i in range(self.num_nodes_x):
for j in range(self.num_nodes_y):
x = i * self.x_step + self.geometry.x_min
y = j * self.y_step + self.geometry.y_min
is_el = self.geometry.is_electrode(x, y)
if not is_el[0] or self.is_boundary(x, y):
node = Node(x, y, node_nr, is_el[0], is_el[1])
self.nodes.append(node)
self.grid[i, j] = node_nr
node_nr = node_nr + 1
self.make_elements(i, j)
util.toc("Generating mesh: %.2f s")
print("Num. of nodes: ", len(self.nodes))
print("Num. of elements: ", len(self.elements))
def boundary_conditions(self):
'''
Incorporates the boundary conditions into the matrix equation.
Currently uses loops, but efficient numpy matrix operations could also be used
'''
util.tic()
self.b = np.zeros(len(self.mesh.nodes)) # RHS of the matrix eq
for node in self.mesh.nodes:
if node.on_el:
for i in range(len(self.mesh.nodes)):
if not self.mesh.nodes[i].on_el:
# T.PLANK'S SOL DIDN'T DO THIS!
self.b[i] = self.b[i]-self.sys[i, node.nr]*node.u
#print(self.sys[i, node.nr]*node.u)
self.sys[i, node.nr] = 0
self.sys[node.nr, i] = 0
self.b[node.nr] = node.u
self.sys[node.nr, node.nr] = 1
util.toc("Processed boundary conditions: %0.2f s")
def draw(self):
util.tic()
x=[]
y=[]
z=np.zeros((self.mesh.num_nodes_x, self.mesh.num_nodes_y))
for i in range(self.mesh.num_nodes_x):
for j in range(self.mesh.num_nodes_y):
if self.mesh.grid[i, j] != -1:
z[j,i] = self.u[self.mesh.grid[i,j]]
else:
xp = i*self.mesh.x_step+self.mesh.geometry.x_min
yp = j*self.mesh.y_step+self.mesh.geometry.y_min
z[j,i] = self.mesh.geometry.is_electrode(xp,yp)[1]
for i in range(self.mesh.num_nodes_x):
xp = i*self.mesh.x_step+self.mesh.geometry.x_min
x.append(xp)
for j in range(self.mesh.num_nodes_y):
yp = j*self.mesh.y_step+self.mesh.geometry.y_min
y.append(yp)
plt.contourf(x, y, z, 30, zorder=0)
plt.colorbar()
util.toc("Drawing solution: %.2f s")