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")