1109 lines
44 KiB
Python
1109 lines
44 KiB
Python
"""
|
|
This module can be used to solve problems related
|
|
to 2D Trusses.
|
|
"""
|
|
|
|
|
|
from cmath import atan, inf
|
|
from sympy.core.add import Add
|
|
from sympy.core.evalf import INF
|
|
from sympy.core.mul import Mul
|
|
from sympy.core.symbol import Symbol
|
|
from sympy.core.sympify import sympify
|
|
from sympy import Matrix, pi
|
|
from sympy.external.importtools import import_module
|
|
from sympy.functions.elementary.miscellaneous import sqrt
|
|
from sympy.matrices.dense import zeros
|
|
import math
|
|
from sympy.physics.units.quantities import Quantity
|
|
from sympy.plotting import plot
|
|
from sympy.utilities.decorator import doctest_depends_on
|
|
from sympy import sin, cos
|
|
|
|
|
|
__doctest_requires__ = {('Truss.draw'): ['matplotlib']}
|
|
|
|
|
|
numpy = import_module('numpy', import_kwargs={'fromlist':['arange']})
|
|
|
|
|
|
class Truss:
|
|
"""
|
|
A Truss is an assembly of members such as beams,
|
|
connected by nodes, that create a rigid structure.
|
|
In engineering, a truss is a structure that
|
|
consists of two-force members only.
|
|
|
|
Trusses are extremely important in engineering applications
|
|
and can be seen in numerous real-world applications like bridges.
|
|
|
|
Examples
|
|
========
|
|
|
|
There is a Truss consisting of four nodes and five
|
|
members connecting the nodes. A force P acts
|
|
downward on the node D and there also exist pinned
|
|
and roller joints on the nodes A and B respectively.
|
|
|
|
.. image:: truss_example.png
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(("node_1", 0, 0), ("node_2", 6, 0), ("node_3", 2, 2), ("node_4", 2, 0))
|
|
>>> t.add_member(("member_1", "node_1", "node_4"), ("member_2", "node_2", "node_4"), ("member_3", "node_1", "node_3"))
|
|
>>> t.add_member(("member_4", "node_2", "node_3"), ("member_5", "node_3", "node_4"))
|
|
>>> t.apply_load(("node_4", 10, 270))
|
|
>>> t.apply_support(("node_1", "pinned"), ("node_2", "roller"))
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
Initializes the class
|
|
"""
|
|
self._nodes = []
|
|
self._members = {}
|
|
self._loads = {}
|
|
self._supports = {}
|
|
self._node_labels = []
|
|
self._node_positions = []
|
|
self._node_position_x = []
|
|
self._node_position_y = []
|
|
self._nodes_occupied = {}
|
|
self._member_lengths = {}
|
|
self._reaction_loads = {}
|
|
self._internal_forces = {}
|
|
self._node_coordinates = {}
|
|
|
|
@property
|
|
def nodes(self):
|
|
"""
|
|
Returns the nodes of the truss along with their positions.
|
|
"""
|
|
return self._nodes
|
|
|
|
@property
|
|
def node_labels(self):
|
|
"""
|
|
Returns the node labels of the truss.
|
|
"""
|
|
return self._node_labels
|
|
|
|
@property
|
|
def node_positions(self):
|
|
"""
|
|
Returns the positions of the nodes of the truss.
|
|
"""
|
|
return self._node_positions
|
|
|
|
@property
|
|
def members(self):
|
|
"""
|
|
Returns the members of the truss along with the start and end points.
|
|
"""
|
|
return self._members
|
|
|
|
@property
|
|
def member_lengths(self):
|
|
"""
|
|
Returns the length of each member of the truss.
|
|
"""
|
|
return self._member_lengths
|
|
|
|
@property
|
|
def supports(self):
|
|
"""
|
|
Returns the nodes with provided supports along with the kind of support provided i.e.
|
|
pinned or roller.
|
|
"""
|
|
return self._supports
|
|
|
|
@property
|
|
def loads(self):
|
|
"""
|
|
Returns the loads acting on the truss.
|
|
"""
|
|
return self._loads
|
|
|
|
@property
|
|
def reaction_loads(self):
|
|
"""
|
|
Returns the reaction forces for all supports which are all initialized to 0.
|
|
"""
|
|
return self._reaction_loads
|
|
|
|
@property
|
|
def internal_forces(self):
|
|
"""
|
|
Returns the internal forces for all members which are all initialized to 0.
|
|
"""
|
|
return self._internal_forces
|
|
|
|
def add_node(self, *args):
|
|
"""
|
|
This method adds a node to the truss along with its name/label and its location.
|
|
Multiple nodes can be added at the same time.
|
|
|
|
Parameters
|
|
==========
|
|
The input(s) for this method are tuples of the form (label, x, y).
|
|
|
|
label: String or a Symbol
|
|
The label for a node. It is the only way to identify a particular node.
|
|
|
|
x: Sympifyable
|
|
The x-coordinate of the position of the node.
|
|
|
|
y: Sympifyable
|
|
The y-coordinate of the position of the node.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0))
|
|
>>> t.nodes
|
|
[('A', 0, 0)]
|
|
>>> t.add_node(('B', 3, 0), ('C', 4, 1))
|
|
>>> t.nodes
|
|
[('A', 0, 0), ('B', 3, 0), ('C', 4, 1)]
|
|
"""
|
|
|
|
for i in args:
|
|
label = i[0]
|
|
x = i[1]
|
|
x = sympify(x)
|
|
y=i[2]
|
|
y = sympify(y)
|
|
if label in self._node_coordinates:
|
|
raise ValueError("Node needs to have a unique label")
|
|
|
|
elif [x, y] in self._node_coordinates.values():
|
|
raise ValueError("A node already exists at the given position")
|
|
|
|
else :
|
|
self._nodes.append((label, x, y))
|
|
self._node_labels.append(label)
|
|
self._node_positions.append((x, y))
|
|
self._node_position_x.append(x)
|
|
self._node_position_y.append(y)
|
|
self._node_coordinates[label] = [x, y]
|
|
|
|
|
|
|
|
def remove_node(self, *args):
|
|
"""
|
|
This method removes a node from the truss.
|
|
Multiple nodes can be removed at the same time.
|
|
|
|
Parameters
|
|
==========
|
|
The input(s) for this method are the labels of the nodes to be removed.
|
|
|
|
label: String or Symbol
|
|
The label of the node to be removed.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0), ('B', 3, 0), ('C', 5, 0))
|
|
>>> t.nodes
|
|
[('A', 0, 0), ('B', 3, 0), ('C', 5, 0)]
|
|
>>> t.remove_node('A', 'C')
|
|
>>> t.nodes
|
|
[('B', 3, 0)]
|
|
"""
|
|
for label in args:
|
|
for i in range(len(self.nodes)):
|
|
if self._node_labels[i] == label:
|
|
x = self._node_position_x[i]
|
|
y = self._node_position_y[i]
|
|
|
|
if label not in self._node_coordinates:
|
|
raise ValueError("No such node exists in the truss")
|
|
|
|
else:
|
|
members_duplicate = self._members.copy()
|
|
for member in members_duplicate:
|
|
if label == self._members[member][0] or label == self._members[member][1]:
|
|
raise ValueError("The given node already has member attached to it")
|
|
self._nodes.remove((label, x, y))
|
|
self._node_labels.remove(label)
|
|
self._node_positions.remove((x, y))
|
|
self._node_position_x.remove(x)
|
|
self._node_position_y.remove(y)
|
|
if label in self._loads:
|
|
self._loads.pop(label)
|
|
if label in self._supports:
|
|
self._supports.pop(label)
|
|
self._node_coordinates.pop(label)
|
|
|
|
|
|
|
|
def add_member(self, *args):
|
|
"""
|
|
This method adds a member between any two nodes in the given truss.
|
|
|
|
Parameters
|
|
==========
|
|
The input(s) of the method are tuple(s) of the form (label, start, end).
|
|
|
|
label: String or Symbol
|
|
The label for a member. It is the only way to identify a particular member.
|
|
|
|
start: String or Symbol
|
|
The label of the starting point/node of the member.
|
|
|
|
end: String or Symbol
|
|
The label of the ending point/node of the member.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0), ('B', 3, 0), ('C', 2, 2))
|
|
>>> t.add_member(('AB', 'A', 'B'), ('BC', 'B', 'C'))
|
|
>>> t.members
|
|
{'AB': ['A', 'B'], 'BC': ['B', 'C']}
|
|
"""
|
|
for i in args:
|
|
label = i[0]
|
|
start = i[1]
|
|
end = i[2]
|
|
|
|
if start not in self._node_coordinates or end not in self._node_coordinates or start==end:
|
|
raise ValueError("The start and end points of the member must be unique nodes")
|
|
|
|
elif label in self._members:
|
|
raise ValueError("A member with the same label already exists for the truss")
|
|
|
|
elif self._nodes_occupied.get((start, end)):
|
|
raise ValueError("A member already exists between the two nodes")
|
|
|
|
else:
|
|
self._members[label] = [start, end]
|
|
self._member_lengths[label] = sqrt((self._node_coordinates[end][0]-self._node_coordinates[start][0])**2 + (self._node_coordinates[end][1]-self._node_coordinates[start][1])**2)
|
|
self._nodes_occupied[start, end] = True
|
|
self._nodes_occupied[end, start] = True
|
|
self._internal_forces[label] = 0
|
|
|
|
def remove_member(self, *args):
|
|
"""
|
|
This method removes members from the given truss.
|
|
|
|
Parameters
|
|
==========
|
|
labels: String or Symbol
|
|
The label for the member to be removed.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0), ('B', 3, 0), ('C', 2, 2))
|
|
>>> t.add_member(('AB', 'A', 'B'), ('AC', 'A', 'C'), ('BC', 'B', 'C'))
|
|
>>> t.members
|
|
{'AB': ['A', 'B'], 'AC': ['A', 'C'], 'BC': ['B', 'C']}
|
|
>>> t.remove_member('AC', 'BC')
|
|
>>> t.members
|
|
{'AB': ['A', 'B']}
|
|
"""
|
|
for label in args:
|
|
if label not in self._members:
|
|
raise ValueError("No such member exists in the Truss")
|
|
|
|
else:
|
|
self._nodes_occupied.pop((self._members[label][0], self._members[label][1]))
|
|
self._nodes_occupied.pop((self._members[label][1], self._members[label][0]))
|
|
self._members.pop(label)
|
|
self._member_lengths.pop(label)
|
|
self._internal_forces.pop(label)
|
|
|
|
def change_node_label(self, *args):
|
|
"""
|
|
This method changes the label(s) of the specified node(s).
|
|
|
|
Parameters
|
|
==========
|
|
The input(s) of this method are tuple(s) of the form (label, new_label).
|
|
|
|
label: String or Symbol
|
|
The label of the node for which the label has
|
|
to be changed.
|
|
|
|
new_label: String or Symbol
|
|
The new label of the node.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0), ('B', 3, 0))
|
|
>>> t.nodes
|
|
[('A', 0, 0), ('B', 3, 0)]
|
|
>>> t.change_node_label(('A', 'C'), ('B', 'D'))
|
|
>>> t.nodes
|
|
[('C', 0, 0), ('D', 3, 0)]
|
|
"""
|
|
for i in args:
|
|
label = i[0]
|
|
new_label = i[1]
|
|
if label not in self._node_coordinates:
|
|
raise ValueError("No such node exists for the Truss")
|
|
elif new_label in self._node_coordinates:
|
|
raise ValueError("A node with the given label already exists")
|
|
else:
|
|
for node in self._nodes:
|
|
if node[0] == label:
|
|
self._nodes[self._nodes.index((label, node[1], node[2]))] = (new_label, node[1], node[2])
|
|
self._node_labels[self._node_labels.index(node[0])] = new_label
|
|
self._node_coordinates[new_label] = self._node_coordinates[label]
|
|
self._node_coordinates.pop(label)
|
|
if node[0] in self._supports:
|
|
self._supports[new_label] = self._supports[node[0]]
|
|
self._supports.pop(node[0])
|
|
if new_label in self._supports:
|
|
if self._supports[new_label] == 'pinned':
|
|
if 'R_'+str(label)+'_x' in self._reaction_loads and 'R_'+str(label)+'_y' in self._reaction_loads:
|
|
self._reaction_loads['R_'+str(new_label)+'_x'] = self._reaction_loads['R_'+str(label)+'_x']
|
|
self._reaction_loads['R_'+str(new_label)+'_y'] = self._reaction_loads['R_'+str(label)+'_y']
|
|
self._reaction_loads.pop('R_'+str(label)+'_x')
|
|
self._reaction_loads.pop('R_'+str(label)+'_y')
|
|
self._loads[new_label] = self._loads[label]
|
|
for load in self._loads[new_label]:
|
|
if load[1] == 90:
|
|
load[0] -= Symbol('R_'+str(label)+'_y')
|
|
if load[0] == 0:
|
|
self._loads[label].remove(load)
|
|
break
|
|
for load in self._loads[new_label]:
|
|
if load[1] == 0:
|
|
load[0] -= Symbol('R_'+str(label)+'_x')
|
|
if load[0] == 0:
|
|
self._loads[label].remove(load)
|
|
break
|
|
self.apply_load(new_label, Symbol('R_'+str(new_label)+'_x'), 0)
|
|
self.apply_load(new_label, Symbol('R_'+str(new_label)+'_y'), 90)
|
|
self._loads.pop(label)
|
|
elif self._supports[new_label] == 'roller':
|
|
self._loads[new_label] = self._loads[label]
|
|
for load in self._loads[label]:
|
|
if load[1] == 90:
|
|
load[0] -= Symbol('R_'+str(label)+'_y')
|
|
if load[0] == 0:
|
|
self._loads[label].remove(load)
|
|
break
|
|
self.apply_load(new_label, Symbol('R_'+str(new_label)+'_y'), 90)
|
|
self._loads.pop(label)
|
|
else:
|
|
if label in self._loads:
|
|
self._loads[new_label] = self._loads[label]
|
|
self._loads.pop(label)
|
|
for member in self._members:
|
|
if self._members[member][0] == node[0]:
|
|
self._members[member][0] = new_label
|
|
self._nodes_occupied[(new_label, self._members[member][1])] = True
|
|
self._nodes_occupied[(self._members[member][1], new_label)] = True
|
|
self._nodes_occupied.pop((label, self._members[member][1]))
|
|
self._nodes_occupied.pop((self._members[member][1], label))
|
|
elif self._members[member][1] == node[0]:
|
|
self._members[member][1] = new_label
|
|
self._nodes_occupied[(self._members[member][0], new_label)] = True
|
|
self._nodes_occupied[(new_label, self._members[member][0])] = True
|
|
self._nodes_occupied.pop((self._members[member][0], label))
|
|
self._nodes_occupied.pop((label, self._members[member][0]))
|
|
|
|
def change_member_label(self, *args):
|
|
"""
|
|
This method changes the label(s) of the specified member(s).
|
|
|
|
Parameters
|
|
==========
|
|
The input(s) of this method are tuple(s) of the form (label, new_label)
|
|
|
|
label: String or Symbol
|
|
The label of the member for which the label has
|
|
to be changed.
|
|
|
|
new_label: String or Symbol
|
|
The new label of the member.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0), ('B', 3, 0), ('D', 5, 0))
|
|
>>> t.nodes
|
|
[('A', 0, 0), ('B', 3, 0), ('D', 5, 0)]
|
|
>>> t.change_node_label(('A', 'C'))
|
|
>>> t.nodes
|
|
[('C', 0, 0), ('B', 3, 0), ('D', 5, 0)]
|
|
>>> t.add_member(('BC', 'B', 'C'), ('BD', 'B', 'D'))
|
|
>>> t.members
|
|
{'BC': ['B', 'C'], 'BD': ['B', 'D']}
|
|
>>> t.change_member_label(('BC', 'BC_new'), ('BD', 'BD_new'))
|
|
>>> t.members
|
|
{'BC_new': ['B', 'C'], 'BD_new': ['B', 'D']}
|
|
"""
|
|
for i in args:
|
|
label = i[0]
|
|
new_label = i[1]
|
|
if label not in self._members:
|
|
raise ValueError("No such member exists for the Truss")
|
|
else:
|
|
members_duplicate = list(self._members).copy()
|
|
for member in members_duplicate:
|
|
if member == label:
|
|
self._members[new_label] = [self._members[member][0], self._members[member][1]]
|
|
self._members.pop(label)
|
|
self._member_lengths[new_label] = self._member_lengths[label]
|
|
self._member_lengths.pop(label)
|
|
self._internal_forces[new_label] = self._internal_forces[label]
|
|
self._internal_forces.pop(label)
|
|
|
|
def apply_load(self, *args):
|
|
"""
|
|
This method applies external load(s) at the specified node(s).
|
|
|
|
Parameters
|
|
==========
|
|
The input(s) of the method are tuple(s) of the form (location, magnitude, direction).
|
|
|
|
location: String or Symbol
|
|
Label of the Node at which load is applied.
|
|
|
|
magnitude: Sympifyable
|
|
Magnitude of the load applied. It must always be positive and any changes in
|
|
the direction of the load are not reflected here.
|
|
|
|
direction: Sympifyable
|
|
The angle, in degrees, that the load vector makes with the horizontal
|
|
in the counter-clockwise direction. It takes the values 0 to 360,
|
|
inclusive.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> from sympy import symbols
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0), ('B', 3, 0))
|
|
>>> P = symbols('P')
|
|
>>> t.apply_load(('A', P, 90), ('A', P/2, 45), ('A', P/4, 90))
|
|
>>> t.loads
|
|
{'A': [[P, 90], [P/2, 45], [P/4, 90]]}
|
|
"""
|
|
for i in args:
|
|
location = i[0]
|
|
magnitude = i[1]
|
|
direction = i[2]
|
|
magnitude = sympify(magnitude)
|
|
direction = sympify(direction)
|
|
|
|
if location not in self._node_coordinates:
|
|
raise ValueError("Load must be applied at a known node")
|
|
|
|
else:
|
|
if location in self._loads:
|
|
self._loads[location].append([magnitude, direction])
|
|
else:
|
|
self._loads[location] = [[magnitude, direction]]
|
|
|
|
def remove_load(self, *args):
|
|
"""
|
|
This method removes already
|
|
present external load(s) at specified node(s).
|
|
|
|
Parameters
|
|
==========
|
|
The input(s) of this method are tuple(s) of the form (location, magnitude, direction).
|
|
|
|
location: String or Symbol
|
|
Label of the Node at which load is applied and is to be removed.
|
|
|
|
magnitude: Sympifyable
|
|
Magnitude of the load applied.
|
|
|
|
direction: Sympifyable
|
|
The angle, in degrees, that the load vector makes with the horizontal
|
|
in the counter-clockwise direction. It takes the values 0 to 360,
|
|
inclusive.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> from sympy import symbols
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0), ('B', 3, 0))
|
|
>>> P = symbols('P')
|
|
>>> t.apply_load(('A', P, 90), ('A', P/2, 45), ('A', P/4, 90))
|
|
>>> t.loads
|
|
{'A': [[P, 90], [P/2, 45], [P/4, 90]]}
|
|
>>> t.remove_load(('A', P/4, 90), ('A', P/2, 45))
|
|
>>> t.loads
|
|
{'A': [[P, 90]]}
|
|
"""
|
|
for i in args:
|
|
location = i[0]
|
|
magnitude = i[1]
|
|
direction = i[2]
|
|
magnitude = sympify(magnitude)
|
|
direction = sympify(direction)
|
|
|
|
if location not in self._node_coordinates:
|
|
raise ValueError("Load must be removed from a known node")
|
|
|
|
else:
|
|
if [magnitude, direction] not in self._loads[location]:
|
|
raise ValueError("No load of this magnitude and direction has been applied at this node")
|
|
else:
|
|
self._loads[location].remove([magnitude, direction])
|
|
if self._loads[location] == []:
|
|
self._loads.pop(location)
|
|
|
|
def apply_support(self, *args):
|
|
"""
|
|
This method adds a pinned or roller support at specified node(s).
|
|
|
|
Parameters
|
|
==========
|
|
The input(s) of this method are of the form (location, type).
|
|
|
|
location: String or Symbol
|
|
Label of the Node at which support is added.
|
|
|
|
type: String
|
|
Type of the support being provided at the node.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0), ('B', 3, 0))
|
|
>>> t.apply_support(('A', 'pinned'), ('B', 'roller'))
|
|
>>> t.supports
|
|
{'A': 'pinned', 'B': 'roller'}
|
|
"""
|
|
for i in args:
|
|
location = i[0]
|
|
type = i[1]
|
|
if location not in self._node_coordinates:
|
|
raise ValueError("Support must be added on a known node")
|
|
|
|
else:
|
|
if location not in self._supports:
|
|
if type == 'pinned':
|
|
self.apply_load((location, Symbol('R_'+str(location)+'_x'), 0))
|
|
self.apply_load((location, Symbol('R_'+str(location)+'_y'), 90))
|
|
elif type == 'roller':
|
|
self.apply_load((location, Symbol('R_'+str(location)+'_y'), 90))
|
|
elif self._supports[location] == 'pinned':
|
|
if type == 'roller':
|
|
self.remove_load((location, Symbol('R_'+str(location)+'_x'), 0))
|
|
elif self._supports[location] == 'roller':
|
|
if type == 'pinned':
|
|
self.apply_load((location, Symbol('R_'+str(location)+'_x'), 0))
|
|
self._supports[location] = type
|
|
|
|
def remove_support(self, *args):
|
|
"""
|
|
This method removes support from specified node(s.)
|
|
|
|
Parameters
|
|
==========
|
|
|
|
locations: String or Symbol
|
|
Label of the Node(s) at which support is to be removed.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(('A', 0, 0), ('B', 3, 0))
|
|
>>> t.apply_support(('A', 'pinned'), ('B', 'roller'))
|
|
>>> t.supports
|
|
{'A': 'pinned', 'B': 'roller'}
|
|
>>> t.remove_support('A','B')
|
|
>>> t.supports
|
|
{}
|
|
"""
|
|
for location in args:
|
|
|
|
if location not in self._node_coordinates:
|
|
raise ValueError("No such node exists in the Truss")
|
|
|
|
elif location not in self._supports:
|
|
raise ValueError("No support has been added to the given node")
|
|
|
|
else:
|
|
if self._supports[location] == 'pinned':
|
|
self.remove_load((location, Symbol('R_'+str(location)+'_x'), 0))
|
|
self.remove_load((location, Symbol('R_'+str(location)+'_y'), 90))
|
|
elif self._supports[location] == 'roller':
|
|
self.remove_load((location, Symbol('R_'+str(location)+'_y'), 90))
|
|
self._supports.pop(location)
|
|
|
|
def solve(self):
|
|
"""
|
|
This method solves for all reaction forces of all supports and all internal forces
|
|
of all the members in the truss, provided the Truss is solvable.
|
|
|
|
A Truss is solvable if the following condition is met,
|
|
|
|
2n >= r + m
|
|
|
|
Where n is the number of nodes, r is the number of reaction forces, where each pinned
|
|
support has 2 reaction forces and each roller has 1, and m is the number of members.
|
|
|
|
The given condition is derived from the fact that a system of equations is solvable
|
|
only when the number of variables is lesser than or equal to the number of equations.
|
|
Equilibrium Equations in x and y directions give two equations per node giving 2n number
|
|
equations. However, the truss needs to be stable as well and may be unstable if 2n > r + m.
|
|
The number of variables is simply the sum of the number of reaction forces and member
|
|
forces.
|
|
|
|
.. note::
|
|
The sign convention for the internal forces present in a member revolves around whether each
|
|
force is compressive or tensile. While forming equations for each node, internal force due
|
|
to a member on the node is assumed to be away from the node i.e. each force is assumed to
|
|
be compressive by default. Hence, a positive value for an internal force implies the
|
|
presence of compressive force in the member and a negative value implies a tensile force.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> t = Truss()
|
|
>>> t.add_node(("node_1", 0, 0), ("node_2", 6, 0), ("node_3", 2, 2), ("node_4", 2, 0))
|
|
>>> t.add_member(("member_1", "node_1", "node_4"), ("member_2", "node_2", "node_4"), ("member_3", "node_1", "node_3"))
|
|
>>> t.add_member(("member_4", "node_2", "node_3"), ("member_5", "node_3", "node_4"))
|
|
>>> t.apply_load(("node_4", 10, 270))
|
|
>>> t.apply_support(("node_1", "pinned"), ("node_2", "roller"))
|
|
>>> t.solve()
|
|
>>> t.reaction_loads
|
|
{'R_node_1_x': 0, 'R_node_1_y': 20/3, 'R_node_2_y': 10/3}
|
|
>>> t.internal_forces
|
|
{'member_1': 20/3, 'member_2': 20/3, 'member_3': -20*sqrt(2)/3, 'member_4': -10*sqrt(5)/3, 'member_5': 10}
|
|
"""
|
|
count_reaction_loads = 0
|
|
for node in self._nodes:
|
|
if node[0] in self._supports:
|
|
if self._supports[node[0]]=='pinned':
|
|
count_reaction_loads += 2
|
|
elif self._supports[node[0]]=='roller':
|
|
count_reaction_loads += 1
|
|
if 2*len(self._nodes) != len(self._members) + count_reaction_loads:
|
|
raise ValueError("The given truss cannot be solved")
|
|
coefficients_matrix = [[0 for i in range(2*len(self._nodes))] for j in range(2*len(self._nodes))]
|
|
load_matrix = zeros(2*len(self.nodes), 1)
|
|
load_matrix_row = 0
|
|
for node in self._nodes:
|
|
if node[0] in self._loads:
|
|
for load in self._loads[node[0]]:
|
|
if load[0]!=Symbol('R_'+str(node[0])+'_x') and load[0]!=Symbol('R_'+str(node[0])+'_y'):
|
|
load_matrix[load_matrix_row] -= load[0]*cos(pi*load[1]/180)
|
|
load_matrix[load_matrix_row + 1] -= load[0]*sin(pi*load[1]/180)
|
|
load_matrix_row += 2
|
|
cols = 0
|
|
row = 0
|
|
for node in self._nodes:
|
|
if node[0] in self._supports:
|
|
if self._supports[node[0]]=='pinned':
|
|
coefficients_matrix[row][cols] += 1
|
|
coefficients_matrix[row+1][cols+1] += 1
|
|
cols += 2
|
|
elif self._supports[node[0]]=='roller':
|
|
coefficients_matrix[row+1][cols] += 1
|
|
cols += 1
|
|
row += 2
|
|
for member in self._members:
|
|
start = self._members[member][0]
|
|
end = self._members[member][1]
|
|
length = sqrt((self._node_coordinates[start][0]-self._node_coordinates[end][0])**2 + (self._node_coordinates[start][1]-self._node_coordinates[end][1])**2)
|
|
start_index = self._node_labels.index(start)
|
|
end_index = self._node_labels.index(end)
|
|
horizontal_component_start = (self._node_coordinates[end][0]-self._node_coordinates[start][0])/length
|
|
vertical_component_start = (self._node_coordinates[end][1]-self._node_coordinates[start][1])/length
|
|
horizontal_component_end = (self._node_coordinates[start][0]-self._node_coordinates[end][0])/length
|
|
vertical_component_end = (self._node_coordinates[start][1]-self._node_coordinates[end][1])/length
|
|
coefficients_matrix[start_index*2][cols] += horizontal_component_start
|
|
coefficients_matrix[start_index*2+1][cols] += vertical_component_start
|
|
coefficients_matrix[end_index*2][cols] += horizontal_component_end
|
|
coefficients_matrix[end_index*2+1][cols] += vertical_component_end
|
|
cols += 1
|
|
forces_matrix = (Matrix(coefficients_matrix)**-1)*load_matrix
|
|
self._reaction_loads = {}
|
|
i = 0
|
|
min_load = inf
|
|
for node in self._nodes:
|
|
if node[0] in self._loads:
|
|
for load in self._loads[node[0]]:
|
|
if type(load[0]) not in [Symbol, Mul, Add]:
|
|
min_load = min(min_load, load[0])
|
|
for j in range(len(forces_matrix)):
|
|
if type(forces_matrix[j]) not in [Symbol, Mul, Add]:
|
|
if abs(forces_matrix[j]/min_load) <1E-10:
|
|
forces_matrix[j] = 0
|
|
for node in self._nodes:
|
|
if node[0] in self._supports:
|
|
if self._supports[node[0]]=='pinned':
|
|
self._reaction_loads['R_'+str(node[0])+'_x'] = forces_matrix[i]
|
|
self._reaction_loads['R_'+str(node[0])+'_y'] = forces_matrix[i+1]
|
|
i += 2
|
|
elif self._supports[node[0]]=='roller':
|
|
self._reaction_loads['R_'+str(node[0])+'_y'] = forces_matrix[i]
|
|
i += 1
|
|
for member in self._members:
|
|
self._internal_forces[member] = forces_matrix[i]
|
|
i += 1
|
|
return
|
|
|
|
@doctest_depends_on(modules=('numpy',))
|
|
def draw(self, subs_dict=None):
|
|
"""
|
|
Returns a plot object of the Truss with all its nodes, members,
|
|
supports and loads.
|
|
|
|
.. note::
|
|
The user must be careful while entering load values in their
|
|
directions. The draw function assumes a sign convention that
|
|
is used for plotting loads.
|
|
|
|
Given a right-handed coordinate system with XYZ coordinates,
|
|
the supports are assumed to be such that the reaction forces of a
|
|
pinned support is in the +X and +Y direction while those of a
|
|
roller support is in the +Y direction. For the load, the range
|
|
of angles, one can input goes all the way to 360 degrees which, in the
|
|
the plot is the angle that the load vector makes with the positive x-axis in the anticlockwise direction.
|
|
|
|
For example, for a 90-degree angle, the load will be a vertically
|
|
directed along +Y while a 270-degree angle denotes a vertical
|
|
load as well but along -Y.
|
|
|
|
Examples
|
|
========
|
|
|
|
.. plot::
|
|
:context: close-figs
|
|
:format: doctest
|
|
:include-source: True
|
|
|
|
>>> from sympy.physics.continuum_mechanics.truss import Truss
|
|
>>> import math
|
|
>>> t = Truss()
|
|
>>> t.add_node(("A", -4, 0), ("B", 0, 0), ("C", 4, 0), ("D", 8, 0))
|
|
>>> t.add_node(("E", 6, 2/math.sqrt(3)))
|
|
>>> t.add_node(("F", 2, 2*math.sqrt(3)))
|
|
>>> t.add_node(("G", -2, 2/math.sqrt(3)))
|
|
>>> t.add_member(("AB","A","B"), ("BC","B","C"), ("CD","C","D"))
|
|
>>> t.add_member(("AG","A","G"), ("GB","G","B"), ("GF","G","F"))
|
|
>>> t.add_member(("BF","B","F"), ("FC","F","C"), ("CE","C","E"))
|
|
>>> t.add_member(("FE","F","E"), ("DE","D","E"))
|
|
>>> t.apply_support(("A","pinned"), ("D","roller"))
|
|
>>> t.apply_load(("G", 3, 90), ("E", 3, 90), ("F", 2, 90))
|
|
>>> p = t.draw()
|
|
>>> p # doctest: +ELLIPSIS
|
|
Plot object containing:
|
|
[0]: cartesian line: 1 for x over (1.0, 1.0)
|
|
...
|
|
>>> p.show()
|
|
"""
|
|
if not numpy:
|
|
raise ImportError("To use this function numpy module is required")
|
|
|
|
x = Symbol('x')
|
|
|
|
markers = []
|
|
annotations = []
|
|
rectangles = []
|
|
|
|
node_markers = self._draw_nodes(subs_dict)
|
|
markers += node_markers
|
|
|
|
member_rectangles = self._draw_members()
|
|
rectangles += member_rectangles
|
|
|
|
support_markers = self._draw_supports()
|
|
markers += support_markers
|
|
|
|
load_annotations = self._draw_loads()
|
|
annotations += load_annotations
|
|
|
|
xmax = -INF
|
|
xmin = INF
|
|
ymax = -INF
|
|
ymin = INF
|
|
|
|
for node in self._node_coordinates:
|
|
xmax = max(xmax, self._node_coordinates[node][0])
|
|
xmin = min(xmin, self._node_coordinates[node][0])
|
|
ymax = max(ymax, self._node_coordinates[node][1])
|
|
ymin = min(ymin, self._node_coordinates[node][1])
|
|
|
|
lim = max(xmax*1.1-xmin*0.8+1, ymax*1.1-ymin*0.8+1)
|
|
|
|
if lim==xmax*1.1-xmin*0.8+1:
|
|
sing_plot = plot(1, (x, 1, 1), markers=markers, show=False, annotations=annotations, xlim=(xmin-0.05*lim, xmax*1.1), ylim=(xmin-0.05*lim, xmax*1.1), axis=False, rectangles=rectangles)
|
|
|
|
else:
|
|
sing_plot = plot(1, (x, 1, 1), markers=markers, show=False, annotations=annotations, xlim=(ymin-0.05*lim, ymax*1.1), ylim=(ymin-0.05*lim, ymax*1.1), axis=False, rectangles=rectangles)
|
|
|
|
return sing_plot
|
|
|
|
|
|
def _draw_nodes(self, subs_dict):
|
|
node_markers = []
|
|
|
|
for node in self._node_coordinates:
|
|
if (type(self._node_coordinates[node][0]) in (Symbol, Quantity)):
|
|
if self._node_coordinates[node][0] in subs_dict:
|
|
self._node_coordinates[node][0] = subs_dict[self._node_coordinates[node][0]]
|
|
else:
|
|
raise ValueError("provided substituted dictionary is not adequate")
|
|
elif (type(self._node_coordinates[node][0]) == Mul):
|
|
objects = self._node_coordinates[node][0].as_coeff_Mul()
|
|
for object in objects:
|
|
if type(object) in (Symbol, Quantity):
|
|
if subs_dict==None or object not in subs_dict:
|
|
raise ValueError("provided substituted dictionary is not adequate")
|
|
else:
|
|
self._node_coordinates[node][0] /= object
|
|
self._node_coordinates[node][0] *= subs_dict[object]
|
|
|
|
if (type(self._node_coordinates[node][1]) in (Symbol, Quantity)):
|
|
if self._node_coordinates[node][1] in subs_dict:
|
|
self._node_coordinates[node][1] = subs_dict[self._node_coordinates[node][1]]
|
|
else:
|
|
raise ValueError("provided substituted dictionary is not adequate")
|
|
elif (type(self._node_coordinates[node][1]) == Mul):
|
|
objects = self._node_coordinates[node][1].as_coeff_Mul()
|
|
for object in objects:
|
|
if type(object) in (Symbol, Quantity):
|
|
if subs_dict==None or object not in subs_dict:
|
|
raise ValueError("provided substituted dictionary is not adequate")
|
|
else:
|
|
self._node_coordinates[node][1] /= object
|
|
self._node_coordinates[node][1] *= subs_dict[object]
|
|
|
|
for node in self._node_coordinates:
|
|
node_markers.append(
|
|
{
|
|
'args':[[self._node_coordinates[node][0]], [self._node_coordinates[node][1]]],
|
|
'marker':'o',
|
|
'markersize':5,
|
|
'color':'black'
|
|
}
|
|
)
|
|
return node_markers
|
|
|
|
def _draw_members(self):
|
|
|
|
member_rectangles = []
|
|
|
|
xmax = -INF
|
|
xmin = INF
|
|
ymax = -INF
|
|
ymin = INF
|
|
|
|
for node in self._node_coordinates:
|
|
xmax = max(xmax, self._node_coordinates[node][0])
|
|
xmin = min(xmin, self._node_coordinates[node][0])
|
|
ymax = max(ymax, self._node_coordinates[node][1])
|
|
ymin = min(ymin, self._node_coordinates[node][1])
|
|
|
|
if abs(1.1*xmax-0.8*xmin)>abs(1.1*ymax-0.8*ymin):
|
|
max_diff = 1.1*xmax-0.8*xmin
|
|
else:
|
|
max_diff = 1.1*ymax-0.8*ymin
|
|
|
|
for member in self._members:
|
|
x1 = self._node_coordinates[self._members[member][0]][0]
|
|
y1 = self._node_coordinates[self._members[member][0]][1]
|
|
x2 = self._node_coordinates[self._members[member][1]][0]
|
|
y2 = self._node_coordinates[self._members[member][1]][1]
|
|
if x2!=x1 and y2!=y1:
|
|
if x2>x1:
|
|
member_rectangles.append(
|
|
{
|
|
'xy':(x1-0.005*max_diff*cos(pi/4+atan((y2-y1)/(x2-x1)))/2, y1-0.005*max_diff*sin(pi/4+atan((y2-y1)/(x2-x1)))/2),
|
|
'width':sqrt((x1-x2)**2+(y1-y2)**2)+0.005*max_diff/math.sqrt(2),
|
|
'height':0.005*max_diff,
|
|
'angle':180*atan((y2-y1)/(x2-x1))/pi,
|
|
'color':'brown'
|
|
}
|
|
)
|
|
else:
|
|
member_rectangles.append(
|
|
{
|
|
'xy':(x2-0.005*max_diff*cos(pi/4+atan((y2-y1)/(x2-x1)))/2, y2-0.005*max_diff*sin(pi/4+atan((y2-y1)/(x2-x1)))/2),
|
|
'width':sqrt((x1-x2)**2+(y1-y2)**2)+0.005*max_diff/math.sqrt(2),
|
|
'height':0.005*max_diff,
|
|
'angle':180*atan((y2-y1)/(x2-x1))/pi,
|
|
'color':'brown'
|
|
}
|
|
)
|
|
elif y2==y1:
|
|
if x2>x1:
|
|
member_rectangles.append(
|
|
{
|
|
'xy':(x1-0.005*max_diff/2, y1-0.005*max_diff/2),
|
|
'width':sqrt((x1-x2)**2+(y1-y2)**2),
|
|
'height':0.005*max_diff,
|
|
'angle':90*(1-math.copysign(1, x2-x1)),
|
|
'color':'brown'
|
|
}
|
|
)
|
|
else:
|
|
member_rectangles.append(
|
|
{
|
|
'xy':(x1-0.005*max_diff/2, y1-0.005*max_diff/2),
|
|
'width':sqrt((x1-x2)**2+(y1-y2)**2),
|
|
'height':-0.005*max_diff,
|
|
'angle':90*(1-math.copysign(1, x2-x1)),
|
|
'color':'brown'
|
|
}
|
|
)
|
|
else:
|
|
if y1<y2:
|
|
member_rectangles.append(
|
|
{
|
|
'xy':(x1-0.005*max_diff/2, y1-0.005*max_diff/2),
|
|
'width':sqrt((x1-x2)**2+(y1-y2)**2)+0.005*max_diff/2,
|
|
'height':0.005*max_diff,
|
|
'angle':90*math.copysign(1, y2-y1),
|
|
'color':'brown'
|
|
}
|
|
)
|
|
else:
|
|
member_rectangles.append(
|
|
{
|
|
'xy':(x2-0.005*max_diff/2, y2-0.005*max_diff/2),
|
|
'width':-(sqrt((x1-x2)**2+(y1-y2)**2)+0.005*max_diff/2),
|
|
'height':0.005*max_diff,
|
|
'angle':90*math.copysign(1, y2-y1),
|
|
'color':'brown'
|
|
}
|
|
)
|
|
|
|
return member_rectangles
|
|
|
|
def _draw_supports(self):
|
|
support_markers = []
|
|
|
|
xmax = -INF
|
|
xmin = INF
|
|
ymax = -INF
|
|
ymin = INF
|
|
|
|
for node in self._node_coordinates:
|
|
xmax = max(xmax, self._node_coordinates[node][0])
|
|
xmin = min(xmin, self._node_coordinates[node][0])
|
|
ymax = max(ymax, self._node_coordinates[node][1])
|
|
ymin = min(ymin, self._node_coordinates[node][1])
|
|
if abs(1.1*xmax-0.8*xmin)>abs(1.1*ymax-0.8*ymin):
|
|
max_diff = 1.1*xmax-0.8*xmin
|
|
else:
|
|
max_diff = 1.1*ymax-0.8*ymin
|
|
|
|
for node in self._supports:
|
|
if self._supports[node]=='pinned':
|
|
support_markers.append(
|
|
{
|
|
'args':[
|
|
[self._node_coordinates[node][0]],
|
|
[self._node_coordinates[node][1]]
|
|
],
|
|
'marker':6,
|
|
'markersize':15,
|
|
'color':'black',
|
|
'markerfacecolor':'none'
|
|
}
|
|
)
|
|
support_markers.append(
|
|
{
|
|
'args':[
|
|
[self._node_coordinates[node][0]],
|
|
[self._node_coordinates[node][1]-0.035*max_diff]
|
|
],
|
|
'marker':'_',
|
|
'markersize':14,
|
|
'color':'black'
|
|
}
|
|
)
|
|
|
|
elif self._supports[node]=='roller':
|
|
support_markers.append(
|
|
{
|
|
'args':[
|
|
[self._node_coordinates[node][0]],
|
|
[self._node_coordinates[node][1]-0.02*max_diff]
|
|
],
|
|
'marker':'o',
|
|
'markersize':11,
|
|
'color':'black',
|
|
'markerfacecolor':'none'
|
|
}
|
|
)
|
|
support_markers.append(
|
|
{
|
|
'args':[
|
|
[self._node_coordinates[node][0]],
|
|
[self._node_coordinates[node][1]-0.0375*max_diff]
|
|
],
|
|
'marker':'_',
|
|
'markersize':14,
|
|
'color':'black'
|
|
}
|
|
)
|
|
return support_markers
|
|
|
|
def _draw_loads(self):
|
|
load_annotations = []
|
|
|
|
xmax = -INF
|
|
xmin = INF
|
|
ymax = -INF
|
|
ymin = INF
|
|
|
|
for node in self._node_coordinates:
|
|
xmax = max(xmax, self._node_coordinates[node][0])
|
|
xmin = min(xmin, self._node_coordinates[node][0])
|
|
ymax = max(ymax, self._node_coordinates[node][1])
|
|
ymin = min(ymin, self._node_coordinates[node][1])
|
|
|
|
if abs(1.1*xmax-0.8*xmin)>abs(1.1*ymax-0.8*ymin):
|
|
max_diff = 1.1*xmax-0.8*xmin+5
|
|
else:
|
|
max_diff = 1.1*ymax-0.8*ymin+5
|
|
|
|
for node in self._loads:
|
|
for load in self._loads[node]:
|
|
if load[0] in [Symbol('R_'+str(node)+'_x'), Symbol('R_'+str(node)+'_y')]:
|
|
continue
|
|
x = self._node_coordinates[node][0]
|
|
y = self._node_coordinates[node][1]
|
|
load_annotations.append(
|
|
{
|
|
'text':'',
|
|
'xy':(
|
|
x-math.cos(pi*load[1]/180)*(max_diff/100),
|
|
y-math.sin(pi*load[1]/180)*(max_diff/100)
|
|
),
|
|
'xytext':(
|
|
x-(max_diff/100+abs(xmax-xmin)+abs(ymax-ymin))*math.cos(pi*load[1]/180)/20,
|
|
y-(max_diff/100+abs(xmax-xmin)+abs(ymax-ymin))*math.sin(pi*load[1]/180)/20
|
|
),
|
|
'arrowprops':{'width':1.5, 'headlength':5, 'headwidth':5, 'facecolor':'black'}
|
|
}
|
|
)
|
|
return load_annotations
|