def AddNode(self, Name, X, Y, Z):
"""
Adds a new node to the model.
Parameters
----------
Name : string
A unique user-defined name for the node.
X : number
The global X-coordinate of the node.
Y : number
The global Y-coordinate of the node.
Z : number
The global Z-coordinate of the node.
"""
# Create a new node
newNode = Node3D(Name, X, Y, Z)
# Add the new node to the list
self.__Nodes.append(newNode)
def __mesh(self):
mesh_size = self.mesh_size
width = self.width
height = self.height
Xo = self.origin[0]
Yo = self.origin[1]
Zo = self.origin[2]
plane = self.plane
x_control = self.x_control
y_control = self.y_control
element_type = self.element_type
# Add the mesh's boundaries to the list of control points
x_control.append(0)
x_control.append(width)
y_control.append(0)
y_control.append(height)
# Sort the control points and remove duplicate values
x_control = sorted(set(x_control))
y_control = sorted(set(y_control))
# Each node number will be increased by the offset calculated below
node_offset = int(self.start_node[1:]) - 1
# Each element number will be increased by the offset calculated below
element_offset = int(self.start_element[1:]) - 1
# Determine which prefix to assign to new elements
if element_type == 'Quad':
element_prefix = 'Q'
else:
element_prefix = 'R'
# Initialize node numbering
node_num = 1
# Step through each y control point (except the first one which is always zero)
num_rows = 0
num_cols = 0
y = 0
for j in range(1, len(y_control), 1):
# If this is not the first iteration 'y' will be too high at this point.
if j != 1:
y -= h
# Determine the mesh size between this y control point and the previous one
ny = max(1, (y_control[j] - y_control[j - 1])/mesh_size)
h = (y_control[j] - y_control[j - 1])/ceil(ny)
# Adjust 'y' if this is not the first iteration.
if j != 1:
y += h
# Generate nodes between the y control points
while round(y, 10) <= round(y_control[j], 10):
# Count the number of rows of plates as we go
num_rows += 1
# Step through each x control point (except the first one which is always zero)
x = 0
for i in range(1, len(x_control), 1):
# 'x' needs to be adjusted for the same reasons 'y' needed to be adjusted
if i != 1:
x -= b
# Determine the mesh size between this x control point and the previous one
nx = max(1, (x_control[i] - x_control[i - 1])/mesh_size)
b = (x_control[i] - x_control[i - 1])/ceil(nx)
if i != 1:
x += b
# Generate nodes between the x control points
while round(x, 10) <= round(x_control[i], 10):
# Count the number of columns of plates as we go
if y == 0:
num_cols += 1
# Assign the node a name
node_name = 'N' + str(node_num + node_offset)
# Calculate the node's coordinates
if plane == 'XY':
X = Xo + x
Y = Yo + y
Z = Zo + 0
elif plane == 'YZ':
X = Xo + 0
Y = Yo + y
Z = Zo + x
else:
X = Xo + x
Y = Yo + 0
Z = Zo + y
# Add the node to the mesh
self.nodes[node_name] = Node3D(node_name, X, Y, Z)
# Move to the next x coordinate
x += b
# Move to the next node number
node_num += 1
# Move to the next y coordinate
y += h
# At this point `num_cols` and `num_rows` represent the number of columns and rows of
# nodes. We'll adjust these variables to be the number of columns and rows of elements
# instead.
num_cols -= 1
num_rows -= 1
# Create the elements
r = 1
n = 1
for i in range(1, num_cols*num_rows + 1, 1):
# Assign the element a name
element_name = element_prefix + str(i + element_offset)
# Find the attached nodes
i_node = n + (r - 1)
j_node = i_node + 1
m_node = j_node + (num_cols + 1)
n_node = m_node - 1
if i % num_cols == 0:
r += 1
n += 1
if element_type == 'Quad':
self.elements[element_name] = Quad3D(element_name, self.nodes['N' + str(i_node + node_offset)],
self.nodes['N' + str(j_node + node_offset)],
self.nodes['N' + str(m_node + node_offset)],
self.nodes['N' + str(n_node + node_offset)],
self.t, self.E, self.nu)
else:
self.elements[element_name] = Plate3D(element_name, self.nodes['N' + str(i_node + node_offset)],
self.nodes['N' + str(j_node + node_offset)],
self.nodes['N' + str(m_node + node_offset)],
self.nodes['N' + str(n_node + node_offset)],
self.t, self.E, self.nu)
def __mesh(self):
n = self.n # Number of plates in the outside of the ring (coarse mesh)
r1 = self.r1 # The inner radius of the ring
r2 = self.r2 # The center radius of the ring
r3 = self.r3 # The outer radius of the ring
Xo = self.Xo # Global X-coordinate of the center of the ring
Yo = self.Yo # Global Y-coordinate of the center of the ring
Zo = self.Zo # Global Z-coordinate of the center of the ring
theta1 = 2*pi/self.n # Angle between nodes at the inner radius of the ring
theta2 = 2*pi/(self.n*3) # Angle between nodes at the center of the ring
theta3 = 2*pi/(self.n*3) # Angle between nodes at the outer radius of the ring
# Each node number will be increased by the offset calculated below
node_offset = int(self.start_node[1:]) - 1
# Each element number will be increased by the offset calculated below
element_offset = int(self.start_element[1:]) - 1
# Generate the nodes that make up the ring, working from the inside to the outside
angle = 0
for i in range(1, 6*n + 1, 1):
# Assign the node a name
node_name = 'N' + str(i + node_offset)
# Generate the inner radius of nodes
if i <= n:
angle = theta1*(i - 1)
x = Xo + r1*cos(angle)
y = Yo
z = Zo + r1*sin(angle)
# Generate the center radius of nodes
elif i <= 3*n:
if (i - n) == 1:
angle = theta2
elif (i - n) % 2 == 0:
angle += theta2
else:
angle += 2*theta2
x = Xo + r2*cos(angle)
y = Yo
z = Zo + r2*sin(angle)
# Generate the outer radius of nodes
else:
if (i - 3*n) == 1:
angle = 0
else:
angle = theta3*((i - 3*n) - 1)
x = Xo + r3*cos(angle)
y = Yo
z = Zo + r3*sin(angle)
self.nodes[node_name] = Node3D(node_name, x, y, z)
# Generate the elements that make up the ring
for i in range(1, 4*n + 1, 1):
# Assign the element a name
element_name = 'Q' + str(i + element_offset)
if i <= n:
n_node = i
j_node = 2*i + n
i_node = 2*i + n - 1
if i != n:
m_node = i + 1
else:
m_node = 1
elif (i - n) % 3 == 1:
n_node = 1 + (i - (n + 1))//3
m_node = i - (i - (n + 1))//3
j_node = i + 2*n + 1
i_node = i + 2*n
elif (i - n) % 3 == 2:
n_node = i - 1 - (i - (n + 1))//3
m_node = i - (i - (n + 1))//3
j_node = i + 2*n + 1
i_node = i + 2*n
else:
n_node = i - 1 - (i - (n + 1))//3
i_node = i + 2*n
if i != 4*n:
m_node = 2 + (i - (n + 1))//3
j_node = i + 2*n + 1
else:
m_node = 1
j_node = 1 + 3*n
self.elements[element_name] = Quad3D(element_name, self.nodes['N' + str(i_node + node_offset)],
self.nodes['N' + str(j_node + node_offset)],
self.nodes['N' + str(m_node + node_offset)],
self.nodes['N' + str(n_node + node_offset)],
self.t, self.E, self.nu)
def __mesh(self):
"""
Generates the nodes and elements in the mesh.
"""
num_quads = self.num_quads # Number of quadrilaterals in the ring
n = self.num_quads
radius = self.radius # The radius of the ring
height = self.height # The height of the ring
Xo = self.Xo # Global X-coordinate of the center of the bottom of the ring
Yo = self.Yo # Global Y-coordinate of the center of the bottom of the ring
Zo = self.Zo # Global Z-coordinate of the center of the bottom of the ring
# Calculate the angle between nodes in the circumference of the ring
theta = 2*pi/num_quads
# Each node number will be increased by the offset calculated below
node_offset = int(self.start_node[1:]) - 1
# Each element number will be increased by the offset calculated below
element_offset = int(self.start_element[1:]) - 1
# Generate the nodes that make up the ring
angle = 0
for i in range(1, 2*n + 1, 1):
# Assign the node a name
node_name = 'N' + str(i + node_offset)
# Generate the bottom nodes of the ring
if i <= n:
angle = theta*(i - 1)
x = Xo + radius*cos(angle)
y = Yo
z = Zo + radius*sin(angle)
# Generate the top nodes of the ring
else:
angle = theta*((i - n) - 1)
x = Xo + radius*cos(angle)
y = Yo + height
z = Zo + radius*sin(angle)
self.nodes[node_name] = Node3D(node_name, x, y, z)
# Generate the elements that make up the ring
for i in range(1, n + 1, 1):
# Assign the element a name
element_name = 'Q' + str(i + element_offset)
# Assign nodes to the element
n_node = i
i_node = i + n
if i != n:
m_node = i + 1
j_node = i + 1 + n
else:
m_node = 1
j_node = 1 + n
# Create the element and add it to the `elements` dictionary
self.elements[element_name] = Quad3D(element_name, self.nodes['N' + str(i_node + node_offset)],
self.nodes['N' + str(j_node + node_offset)],
self.nodes['N' + str(m_node + node_offset)],
self.nodes['N' + str(n_node + node_offset)],
self.t, self.E, self.nu)
def __mesh(self):
n = self.n # Number of plates in the initial ring
r1 = self.r1 # The inner radius of the ring
r2 = self.r2 # The outer radius of the ring
Xo = self.Xo # Global X-coordinate of the center of the ring
Yo = self.Yo # Global Y-coordinate of the center of the ring
Zo = self.Zo # Global Z-coordinate of the center of the ring
theta = 2*pi/self.n # Angle between nodes in the ring
# Each node number will be increased by the offset calculated below
node_offset = int(self.start_node[1:]) - 1
# Each element number will be increased by the offset calculated below
element_offset = int(self.start_element[1:]) - 1
# Generate the nodes that make up the ring, working from the inside to the outside
angle = 0
for i in range(1, 2*n + 1, 1):
# Assign the node a name
node_name = 'N' + str(i + node_offset)
# Generate the inner radius of nodes
if i <= n:
angle = theta*(i - 1)
x = Xo + r1*cos(angle)
y = Yo
z = Zo + r1*sin(angle)
# Generate the outer radius of nodes
else:
angle = theta*((i - n) - 1)
x = Xo + r2*cos(angle)
y = Yo
z = Zo + r2*sin(angle)
self.nodes[node_name] = Node3D(node_name, x, y, z)
# Generate the elements that make up the ring
for i in range(1, n + 1, 1):
# Assign the element a name
element_name = 'Q' + str(i + element_offset)
n_node = i
i_node = i + n
if i != n:
m_node = i + 1
j_node = i + 1 + n
else:
m_node = 1
j_node = 1 + n
self.elements[element_name] = Quad3D(element_name, self.nodes['N' + str(i_node + node_offset)],
self.nodes['N' + str(j_node + node_offset)],
self.nodes['N' + str(m_node + node_offset)],
self.nodes['N' + str(n_node + node_offset)],
self.t, self.E, self.nu)