def generateNodes(self):
#first lets shift all rectangles sp that all coordinates are positive
minX = 0
minY = 0
for rect in self.rectangles:
for node in rect.nodes:
if node.x < minX:
minX = node.x
if node.y < minY:
minY = node.y
for rect in self.rectangles:
for node in rect.nodes:
node.x = node.x - minX
node.y = node.y - minY
#now generate mesh
mesh = Mesh.Mesh()
for rect in self.rectangles:
nodes = []
#making nodes
nodex = np.arange(rect.nodes[2].x,
round(rect.nodes[0].x + self.dx(), 8), self.dx())
nodey = np.arange(rect.nodes[2].y,
round(rect.nodes[0].y + self.dy(), 8), self.dy())
for i in range(len(nodex)):
for j in range(len(nodey)):
node = Mesh.Node(nodex[i], nodey[j])
#if node is a corner copy the corner node
for rnode in rect.nodes:
if node == rnode:
node = rnode
node = mesh.addNode(node)
nodes.append(node)
#making elements
shift = len(nodey)
elements = []
for i in range(len(nodex) - 1):
for j in range(len(nodey) - 1):
node1 = nodes[shift * i + j + shift + 1]
node2 = nodes[shift * i + j + 1]
node3 = nodes[shift * i + j]
node4 = nodes[shift * i + j + shift]
elemNodes = [node1, node2, node3, node4]
elem = Mesh.Element(elemNodes)
elements.append(elem)
mesh.addElement(elem)
elem.initialConditions['temperature'] = 0
elem.initialConditions['concentration'] = 0
elem.initialConditions['u-velocity'] = 0
elem.initialConditions['v-velocity'] = 0
#defining boundaries
for edge in rect.edges:
if edge in rect.topEdges or edge in rect.botEdges:
shift = len(nodey)
if edge.node1.x > edge.node2.x:
startNode = edge.node2
endNode = edge.node1
else:
startNode = edge.node1
endNode = edge.node2
if edge in rect.topEdges:
side = 'T2'
else:
side = 'B3'
elif edge in rect.leftEdges or edge in rect.rightEdges:
shift = 1
if edge.node1.y > edge.node2.y:
startNode = edge.node2
endNode = edge.node1
else:
startNode = edge.node1
endNode = edge.node2
if edge in rect.leftEdges:
side = 'L1'
else:
side = 'R4'
start = nodes.index(startNode)
end = nodes.index(endNode)
edgeNodes = np.arange(start, end + shift, shift)
if edge in rect.leftEdges or edge in rect.topEdges:
edgeNodes = np.flipud(edgeNodes)
for i in range(len(edgeNodes) - 1):
boundary = Mesh.Boundary(
[nodes[edgeNodes[i]], nodes[edgeNodes[i + 1]]])
nodes[edgeNodes[i]].isBoundary = True
nodes[edgeNodes[i + 1]].isBoundary = True
for elem in elements:
if boundary.nodes[0] in elem.nodes:
if boundary.nodes[1] in elem.nodes:
boundary.element = elem
mesh.addBoundary(boundary)
boundary.conditions['temperature'] = [[0, 1, 0], [0, 1, 0]]
boundary.conditions['concentration'] = [[0, 1, 0],
[0, 1, 0]]
boundary.conditions['u-velocity'] = [[0, 1, 0], [0, 1, 0]]
boundary.conditions['v-velocity'] = [[0, 1, 0], [0, 1, 0]]
boundary.orientation = side
#calculating max nodes in y and max nodes in x for mesh files
nx = 1
ny = 0
for rect in self.rectangles:
if rect.height / self.dy() + 1 > ny:
ny = round(rect.height / self.dy()) + 1
nx = nx + round(rect.width / self.dx())
mesh.nx = nx
mesh.ny = ny
for node in mesh.nodes:
print("nodes nudges")
node.nudge(self.dx(), self.dy())
print("nodes nudges")
#reSkew = True
#while reSkew:
# reSkew = False
# for elem in mesh.elements:
# if elem.badSkew():
# reSkew True
# for node in elem.nodes:
# node.nudge()
# if not elem.badSkew():
# break
self.meshCreated.emit(mesh)
def subDivide(self, elements):
"""
divides an element into 4 smaller pieces.
currently only works with rectangular elements
"""
for element in elements:
maxX = element.nodes[0].x
minX = element.nodes[0].x
maxY = element.nodes[0].y
minY = element.nodes[0].y
for node in element.nodes:
if node.x > maxX:
maxX=node.x
elif node.x<minX:
minX=node.x
if node.y >maxY:
maxY=node.y
elif node.y<minY:
minY=node.y
x = minX + (maxX-minX)/2.0
y = minY + (maxY-minY)/2.0
#initializing new nodes
centreNode = Mesh.Node(x,y)
rightNode = Mesh.Node(maxX,y)
leftNode = Mesh.Node(minX,y)
bottomNode = Mesh.Node(x,minY)
topNode = Mesh.Node(x,maxY)
#making sure no duplicate nodes are being created
for node in self.parent().parent().mesh.nodes:
if node.x == x and node.y == y:
centreNode = node
if node.x == maxX and node.y == y:
rightNode = node
if node.x == minX and node.y == y:
leftNode = node
if node.x == x and node.y == minY:
bottomNode = node
if node.x == x and node.y == maxY:
topNode = node
newElements = [
Mesh.Element([element.nodes[0],topNode,centreNode,rightNode]),
Mesh.Element([topNode,element.nodes[1],leftNode,centreNode]),
Mesh.Element([centreNode,leftNode,element.nodes[2],bottomNode]),
Mesh.Element([rightNode,centreNode,bottomNode, element.nodes[3]])
]
self.parent().parent().mesh.subElement(element)
for newElement in newElements:
self.parent().parent().mesh.addElement(newElement)
newElement.initialConditions = element.initialConditions.copy()
if element.isBoundary:
for boundary in element.boundaries:
if element.nodes[0] in boundary.nodes and element.nodes[1] in boundary.nodes: #top side boundary
newBoundary1 = Mesh.Boundary([element.nodes[0],topNode])
newBoundary1.element = newElements[0]
newElements[0].boundaries.append(newBoundary1)
newElements[0].isBoundary = True
newBoundary2 = Mesh.Boundary([element.nodes[1],topNode])
newBoundary2.element = newElements[1]
newElements[1].boundaries.append(newBoundary2)
newElements[1].isBoundary = True
elif element.nodes[1] in boundary.nodes and element.nodes[2] in boundary.nodes: #left side boundary
newBoundary1 = Mesh.Boundary([element.nodes[1],leftNode])
newBoundary1.element = newElements[1]
newElements[1].boundaries.append(newBoundary1)
newElements[1].isBoundary = True
newBoundary2 = Mesh.Boundary([element.nodes[2],leftNode])
newBoundary2.element = newElements[2]
newElements[2].boundaries.append(newBoundary2)
newElements[2].isBoundary = True
elif element.nodes[2] in boundary.nodes and element.nodes[3] in boundary.nodes: #bottom side boundary
newBoundary1 = Mesh.Boundary([element.nodes[2],bottomNode])
newBoundary1.element = newElements[2]
newElements[2].boundaries.append(newBoundary1)
newElements[2].isBoundary = True
newBoundary2 = Mesh.Boundary([element.nodes[3],bottomNode])
newBoundary2.element = newElements[3]
newElements[3].boundaries.append(newBoundary2)
newElements[3].isBoundary = True
elif element.nodes[3] in boundary.nodes and element.nodes[0] in boundary.nodes: #right side boundary
newBoundary1 = Mesh.Boundary([element.nodes[3],rightNode])
newBoundary1.element = newElements[3]
newElements[3].boundaries.append(newBoundary1)
newElements[3].isBoundary = True
newBoundary2 = Mesh.Boundary([element.nodes[0],rightNode])
newBoundary2.element = newElements[0]
newElements[0].boundaries.append(newBoundary2)
newElements[0].isBoundary = True
newBoundary1.conditions = boundary.conditions.copy()
newBoundary2.conditions = boundary.conditions.copy()
self.parent().parent().mesh.subBoundary(boundary)
self.parent().parent().mesh.addBoundary(newBoundary1)
self.parent().parent().mesh.addBoundary(newBoundary2)
