|
|
""" |
|
|
This module can be used to solve probelsm related to 2D parabolic arches |
|
|
""" |
|
|
from sympy.core.sympify import sympify |
|
|
from sympy.core.symbol import Symbol,symbols |
|
|
from sympy import diff, sqrt, cos , sin, atan, rad, Min |
|
|
from sympy.core.relational import Eq |
|
|
from sympy.solvers.solvers import solve |
|
|
from sympy.functions import Piecewise |
|
|
from sympy.plotting import plot |
|
|
from sympy import limit |
|
|
from sympy.utilities.decorator import doctest_depends_on |
|
|
from sympy.external.importtools import import_module |
|
|
|
|
|
numpy = import_module('numpy', import_kwargs={'fromlist':['arange']}) |
|
|
|
|
|
class Arch: |
|
|
""" |
|
|
This class is used to solve problems related to a three hinged arch(determinate) structure.\n |
|
|
An arch is a curved vertical structure spanning an open space underneath it.\n |
|
|
Arches can be used to reduce the bending moments in long-span structures.\n |
|
|
|
|
|
Arches are used in structural engineering(over windows, door and even bridges)\n |
|
|
because they can support a very large mass placed on top of them. |
|
|
|
|
|
Example |
|
|
======== |
|
|
>>> from sympy.physics.continuum_mechanics.arch import Arch |
|
|
>>> a = Arch((0,0),(10,0),crown_x=5,crown_y=5) |
|
|
>>> a.get_shape_eqn |
|
|
5 - (x - 5)**2/5 |
|
|
|
|
|
>>> from sympy.physics.continuum_mechanics.arch import Arch |
|
|
>>> a = Arch((0,0),(10,1),crown_x=6) |
|
|
>>> a.get_shape_eqn |
|
|
9/5 - (x - 6)**2/20 |
|
|
""" |
|
|
def __init__(self,left_support,right_support,**kwargs): |
|
|
self._shape_eqn = None |
|
|
self._left_support = (sympify(left_support[0]),sympify(left_support[1])) |
|
|
self._right_support = (sympify(right_support[0]),sympify(right_support[1])) |
|
|
self._crown_x = None |
|
|
self._crown_y = None |
|
|
if 'crown_x' in kwargs: |
|
|
self._crown_x = sympify(kwargs['crown_x']) |
|
|
if 'crown_y' in kwargs: |
|
|
self._crown_y = sympify(kwargs['crown_y']) |
|
|
self._shape_eqn = self.get_shape_eqn |
|
|
self._conc_loads = {} |
|
|
self._distributed_loads = {} |
|
|
self._loads = {'concentrated': self._conc_loads, 'distributed':self._distributed_loads} |
|
|
self._loads_applied = {} |
|
|
self._supports = {'left':'hinge', 'right':'hinge'} |
|
|
self._member = None |
|
|
self._member_force = None |
|
|
self._reaction_force = {Symbol('R_A_x'):0, Symbol('R_A_y'):0, Symbol('R_B_x'):0, Symbol('R_B_y'):0} |
|
|
self._points_disc_x = set() |
|
|
self._points_disc_y = set() |
|
|
self._moment_x = {} |
|
|
self._moment_y = {} |
|
|
self._load_x = {} |
|
|
self._load_y = {} |
|
|
self._moment_x_func = Piecewise((0,True)) |
|
|
self._moment_y_func = Piecewise((0,True)) |
|
|
self._load_x_func = Piecewise((0,True)) |
|
|
self._load_y_func = Piecewise((0,True)) |
|
|
self._bending_moment = None |
|
|
self._shear_force = None |
|
|
self._axial_force = None |
|
|
|
|
|
|
|
|
@property |
|
|
def get_shape_eqn(self): |
|
|
"returns the equation of the shape of arch developed" |
|
|
if self._shape_eqn: |
|
|
return self._shape_eqn |
|
|
|
|
|
x,y,c = symbols('x y c') |
|
|
a = Symbol('a',positive=False) |
|
|
if self._crown_x and self._crown_y: |
|
|
x0 = self._crown_x |
|
|
y0 = self._crown_y |
|
|
parabola_eqn = a*(x-x0)**2 + y0 - y |
|
|
eq1 = parabola_eqn.subs({x:self._left_support[0], y:self._left_support[1]}) |
|
|
solution = solve((eq1),(a)) |
|
|
parabola_eqn = solution[0]*(x-x0)**2 + y0 |
|
|
if(parabola_eqn.subs({x:self._right_support[0]}) != self._right_support[1]): |
|
|
raise ValueError("provided coordinates of crown and supports are not consistent with parabolic arch") |
|
|
|
|
|
elif self._crown_x: |
|
|
x0 = self._crown_x |
|
|
parabola_eqn = a*(x-x0)**2 + c - y |
|
|
eq1 = parabola_eqn.subs({x:self._left_support[0], y:self._left_support[1]}) |
|
|
eq2 = parabola_eqn.subs({x:self._right_support[0], y:self._right_support[1]}) |
|
|
solution = solve((eq1,eq2),(a,c)) |
|
|
if len(solution) <2 or solution[a] == 0: |
|
|
raise ValueError("parabolic arch cannot be constructed with the provided coordinates, try providing crown_y") |
|
|
parabola_eqn = solution[a]*(x-x0)**2+ solution[c] |
|
|
self._crown_y = solution[c] |
|
|
|
|
|
else: |
|
|
raise KeyError("please provide crown_x to construct arch") |
|
|
|
|
|
return parabola_eqn |
|
|
|
|
|
@property |
|
|
def get_loads(self): |
|
|
""" |
|
|
return the position of the applied load and angle (for concentrated loads) |
|
|
""" |
|
|
return self._loads |
|
|
|
|
|
@property |
|
|
def supports(self): |
|
|
""" |
|
|
Returns the type of support |
|
|
""" |
|
|
return self._supports |
|
|
|
|
|
@property |
|
|
def left_support(self): |
|
|
""" |
|
|
Returns the position of the left support. |
|
|
""" |
|
|
return self._left_support |
|
|
|
|
|
@property |
|
|
def right_support(self): |
|
|
""" |
|
|
Returns the position of the right support. |
|
|
""" |
|
|
return self._right_support |
|
|
|
|
|
@property |
|
|
def reaction_force(self): |
|
|
""" |
|
|
return the reaction forces generated |
|
|
""" |
|
|
return self._reaction_force |
|
|
|
|
|
def apply_load(self,order,label,start,mag,end=None,angle=None): |
|
|
""" |
|
|
This method adds load to the Arch. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
order : Integer |
|
|
Order of the applied load. |
|
|
|
|
|
- For point/concentrated loads, order = -1 |
|
|
- For distributed load, order = 0 |
|
|
|
|
|
label : String or Symbol |
|
|
The label of the load |
|
|
- should not use 'A' or 'B' as it is used for supports. |
|
|
|
|
|
start : Float |
|
|
|
|
|
- For concentrated/point loads, start is the x coordinate |
|
|
- For distributed loads, start is the starting position of distributed load |
|
|
|
|
|
mag : Sympifyable |
|
|
Magnitude of the applied load. Must be positive |
|
|
|
|
|
end : Float |
|
|
Required for distributed loads |
|
|
|
|
|
- For concentrated/point load , end is None(may not be given) |
|
|
- For distributed loads, end is the end position of distributed load |
|
|
|
|
|
angle: Sympifyable |
|
|
The angle in degrees, the load vector makes with the horizontal |
|
|
in the counter-clockwise direction. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
For applying distributed load |
|
|
|
|
|
>>> from sympy.physics.continuum_mechanics.arch import Arch |
|
|
>>> a = Arch((0,0),(10,0),crown_x=5,crown_y=5) |
|
|
>>> a.apply_load(0,'C',start=3,end=5,mag=-10) |
|
|
|
|
|
For applying point/concentrated_loads |
|
|
|
|
|
>>> from sympy.physics.continuum_mechanics.arch import Arch |
|
|
>>> a = Arch((0,0),(10,0),crown_x=5,crown_y=5) |
|
|
>>> a.apply_load(-1,'C',start=2,mag=15,angle=45) |
|
|
|
|
|
""" |
|
|
y = Symbol('y') |
|
|
x = Symbol('x') |
|
|
x0 = Symbol('x0') |
|
|
|
|
|
order= sympify(order) |
|
|
mag = sympify(mag) |
|
|
angle = sympify(angle) |
|
|
|
|
|
if label in self._loads_applied: |
|
|
raise ValueError("load with the given label already exists") |
|
|
|
|
|
if label in ['A','B']: |
|
|
raise ValueError("cannot use the given label, reserved for supports") |
|
|
|
|
|
if order == 0: |
|
|
if end is None or end<start: |
|
|
raise KeyError("provide end greater than start") |
|
|
|
|
|
self._distributed_loads[label] = {'start':start, 'end':end, 'f_y': mag} |
|
|
self._points_disc_y.add(start) |
|
|
|
|
|
if start in self._moment_y: |
|
|
self._moment_y[start] -= mag*(Min(x,end)-start)*(x0-(start+(Min(x,end)))/2) |
|
|
self._load_y[start] += mag*(Min(end,x)-start) |
|
|
else: |
|
|
self._moment_y[start] = -mag*(Min(x,end)-start)*(x0-(start+(Min(x,end)))/2) |
|
|
self._load_y[start] = mag*(Min(end,x)-start) |
|
|
|
|
|
self._loads_applied[label] = 'distributed' |
|
|
|
|
|
if order == -1: |
|
|
|
|
|
if angle is None: |
|
|
raise TypeError("please provide direction of force") |
|
|
height = self._shape_eqn.subs({'x':start}) |
|
|
|
|
|
self._conc_loads[label] = {'x':start, 'y':height, 'f_x':mag*cos(rad(angle)), 'f_y': mag*sin(rad(angle)), 'mag':mag, 'angle':angle} |
|
|
self._points_disc_x.add(start) |
|
|
self._points_disc_y.add(start) |
|
|
|
|
|
if start in self._moment_x: |
|
|
self._moment_x[start] += self._conc_loads[label]['f_x']*(y-self._conc_loads[label]['y']) |
|
|
self._load_x[start] += self._conc_loads[label]['f_x'] |
|
|
else: |
|
|
self._moment_x[start] = self._conc_loads[label]['f_x']*(y-self._conc_loads[label]['y']) |
|
|
self._load_x[start] = self._conc_loads[label]['f_x'] |
|
|
|
|
|
if start in self._moment_y: |
|
|
self._moment_y[start] -= self._conc_loads[label]['f_y']*(x0-start) |
|
|
self._load_y[start] += self._conc_loads[label]['f_y'] |
|
|
else: |
|
|
self._moment_y[start] = -self._conc_loads[label]['f_y']*(x0-start) |
|
|
self._load_y[start] = self._conc_loads[label]['f_y'] |
|
|
|
|
|
self._loads_applied[label] = 'concentrated' |
|
|
|
|
|
|
|
|
def remove_load(self,label): |
|
|
""" |
|
|
This methods removes the load applied to the arch |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
label : String or Symbol |
|
|
The label of the applied load |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.physics.continuum_mechanics.arch import Arch |
|
|
>>> a = Arch((0,0),(10,0),crown_x=5,crown_y=5) |
|
|
>>> a.apply_load(0,'C',start=3,end=5,mag=-10) |
|
|
>>> a.remove_load('C') |
|
|
removed load C: {'start': 3, 'end': 5, 'f_y': -10} |
|
|
""" |
|
|
y = Symbol('y') |
|
|
x = Symbol('x') |
|
|
x0 = Symbol('x0') |
|
|
|
|
|
if label in self._distributed_loads : |
|
|
|
|
|
self._loads_applied.pop(label) |
|
|
start = self._distributed_loads[label]['start'] |
|
|
end = self._distributed_loads[label]['end'] |
|
|
mag = self._distributed_loads[label]['f_y'] |
|
|
self._points_disc_y.remove(start) |
|
|
self._load_y[start] -= mag*(Min(x,end)-start) |
|
|
self._moment_y[start] += mag*(Min(x,end)-start)*(x0-(start+(Min(x,end)))/2) |
|
|
val = self._distributed_loads.pop(label) |
|
|
print(f"removed load {label}: {val}") |
|
|
|
|
|
elif label in self._conc_loads : |
|
|
|
|
|
self._loads_applied.pop(label) |
|
|
start = self._conc_loads[label]['x'] |
|
|
self._points_disc_x.remove(start) |
|
|
self._points_disc_y.remove(start) |
|
|
self._moment_y[start] += self._conc_loads[label]['f_y']*(x0-start) |
|
|
self._moment_x[start] -= self._conc_loads[label]['f_x']*(y-self._conc_loads[label]['y']) |
|
|
self._load_x[start] -= self._conc_loads[label]['f_x'] |
|
|
self._load_y[start] -= self._conc_loads[label]['f_y'] |
|
|
val = self._conc_loads.pop(label) |
|
|
print(f"removed load {label}: {val}") |
|
|
|
|
|
else : |
|
|
raise ValueError("label not found") |
|
|
|
|
|
def change_support_position(self, left_support=None, right_support=None): |
|
|
""" |
|
|
Change position of supports. |
|
|
If not provided , defaults to the old value. |
|
|
Parameters |
|
|
========== |
|
|
|
|
|
left_support: tuple (x, y) |
|
|
x: float |
|
|
x-coordinate value of the left_support |
|
|
|
|
|
y: float |
|
|
y-coordinate value of the left_support |
|
|
|
|
|
right_support: tuple (x, y) |
|
|
x: float |
|
|
x-coordinate value of the right_support |
|
|
|
|
|
y: float |
|
|
y-coordinate value of the right_support |
|
|
""" |
|
|
if left_support is not None: |
|
|
self._left_support = (left_support[0],left_support[1]) |
|
|
|
|
|
if right_support is not None: |
|
|
self._right_support = (right_support[0],right_support[1]) |
|
|
|
|
|
self._shape_eqn = None |
|
|
self._shape_eqn = self.get_shape_eqn |
|
|
|
|
|
def change_crown_position(self,crown_x=None,crown_y=None): |
|
|
""" |
|
|
Change the position of the crown/hinge of the arch |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
crown_x: Float |
|
|
The x coordinate of the position of the hinge |
|
|
- if not provided, defaults to old value |
|
|
|
|
|
crown_y: Float |
|
|
The y coordinate of the position of the hinge |
|
|
- if not provided defaults to None |
|
|
""" |
|
|
self._crown_x = crown_x |
|
|
self._crown_y = crown_y |
|
|
self._shape_eqn = None |
|
|
self._shape_eqn = self.get_shape_eqn |
|
|
|
|
|
def change_support_type(self,left_support=None,right_support=None): |
|
|
""" |
|
|
Add the type for support at each end. |
|
|
Can use roller or hinge support at each end. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
left_support, right_support : string |
|
|
Type of support at respective end |
|
|
|
|
|
- For roller support , left_support/right_support = "roller" |
|
|
- For hinged support, left_support/right_support = "hinge" |
|
|
- defaults to hinge if value not provided |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
For applying roller support at right end |
|
|
|
|
|
>>> from sympy.physics.continuum_mechanics.arch import Arch |
|
|
>>> a = Arch((0,0),(10,0),crown_x=5,crown_y=5) |
|
|
>>> a.change_support_type(right_support="roller") |
|
|
|
|
|
""" |
|
|
support_types = ['roller','hinge'] |
|
|
if left_support: |
|
|
if left_support not in support_types: |
|
|
raise ValueError("supports must only be roller or hinge") |
|
|
|
|
|
self._supports['left'] = left_support |
|
|
|
|
|
if right_support: |
|
|
if right_support not in support_types: |
|
|
raise ValueError("supports must only be roller or hinge") |
|
|
|
|
|
self._supports['right'] = right_support |
|
|
|
|
|
def add_member(self,y): |
|
|
""" |
|
|
This method adds a member/rod at a particular height y. |
|
|
A rod is used for stability of the structure in case of a roller support. |
|
|
""" |
|
|
if y>self._crown_y or y<min(self._left_support[1], self._right_support[1]): |
|
|
raise ValueError(f"position of support must be between y={min(self._left_support[1], self._right_support[1])} and y={self._crown_y}") |
|
|
x = Symbol('x') |
|
|
a = diff(self._shape_eqn,x).subs(x,self._crown_x+1)/2 |
|
|
x_diff = sqrt((y - self._crown_y)/a) |
|
|
x1 = self._crown_x + x_diff |
|
|
x2 = self._crown_x - x_diff |
|
|
self._member = (x1,x2,y) |
|
|
|
|
|
def shear_force_at(self, pos = None, **kwargs): |
|
|
""" |
|
|
return the shear at some x-coordinates |
|
|
if no x value provided, returns the formula |
|
|
""" |
|
|
if pos is None: |
|
|
return self._shear_force |
|
|
else: |
|
|
x = Symbol('x') |
|
|
if 'dir' in kwargs: |
|
|
dir = kwargs['dir'] |
|
|
return limit(self._shear_force,x,pos,dir=dir) |
|
|
return self._shear_force.subs(x,pos) |
|
|
|
|
|
def bending_moment_at(self, pos = None, **kwargs): |
|
|
""" |
|
|
return the bending moment at some x-coordinates |
|
|
if no x value provided, returns the formula |
|
|
""" |
|
|
if pos is None: |
|
|
return self._bending_moment |
|
|
else: |
|
|
x0 = Symbol('x0') |
|
|
if 'dir' in kwargs: |
|
|
dir = kwargs['dir'] |
|
|
return limit(self._bending_moment,x0,pos,dir=dir) |
|
|
return self._bending_moment.subs(x0,pos) |
|
|
|
|
|
|
|
|
def axial_force_at(self,pos = None, **kwargs): |
|
|
""" |
|
|
return the axial/normal force generated at some x-coordinate |
|
|
if no x value provided, returns the formula |
|
|
""" |
|
|
if pos is None: |
|
|
return self._axial_force |
|
|
else: |
|
|
x = Symbol('x') |
|
|
if 'dir' in kwargs: |
|
|
dir = kwargs['dir'] |
|
|
return limit(self._axial_force,x,pos,dir=dir) |
|
|
return self._axial_force.subs(x,pos) |
|
|
|
|
|
def solve(self): |
|
|
""" |
|
|
This method solves for the reaction forces generated at the supports,\n |
|
|
and bending moment and generated in the arch and tension produced in the member if used. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.physics.continuum_mechanics.arch import Arch |
|
|
>>> a = Arch((0,0),(10,0),crown_x=5,crown_y=5) |
|
|
>>> a.apply_load(0,'C',start=3,end=5,mag=-10) |
|
|
>>> a.solve() |
|
|
>>> a.reaction_force |
|
|
{R_A_x: 8, R_A_y: 12, R_B_x: -8, R_B_y: 8} |
|
|
|
|
|
>>> from sympy import Symbol |
|
|
>>> t = Symbol('t') |
|
|
>>> from sympy.physics.continuum_mechanics.arch import Arch |
|
|
>>> a = Arch((0,0),(16,0),crown_x=8,crown_y=5) |
|
|
>>> a.apply_load(0,'C',start=3,end=5,mag=t) |
|
|
>>> a.solve() |
|
|
>>> a.reaction_force |
|
|
{R_A_x: -4*t/5, R_A_y: -3*t/2, R_B_x: 4*t/5, R_B_y: -t/2} |
|
|
|
|
|
>>> a.bending_moment_at(4) |
|
|
-5*t/2 |
|
|
""" |
|
|
y = Symbol('y') |
|
|
x = Symbol('x') |
|
|
x0 = Symbol('x0') |
|
|
|
|
|
discontinuity_points_x = sorted(self._points_disc_x) |
|
|
discontinuity_points_y = sorted(self._points_disc_y) |
|
|
|
|
|
self._moment_x_func = Piecewise((0,True)) |
|
|
self._moment_y_func = Piecewise((0,True)) |
|
|
|
|
|
self._load_x_func = Piecewise((0,True)) |
|
|
self._load_y_func = Piecewise((0,True)) |
|
|
|
|
|
accumulated_x_moment = 0 |
|
|
accumulated_y_moment = 0 |
|
|
|
|
|
accumulated_x_load = 0 |
|
|
accumulated_y_load = 0 |
|
|
|
|
|
for point in discontinuity_points_x: |
|
|
cond = (x >= point) |
|
|
accumulated_x_load += self._load_x[point] |
|
|
accumulated_x_moment += self._moment_x[point] |
|
|
self._load_x_func = Piecewise((accumulated_x_load,cond),(self._load_x_func,True)) |
|
|
self._moment_x_func = Piecewise((accumulated_x_moment,cond),(self._moment_x_func,True)) |
|
|
|
|
|
for point in discontinuity_points_y: |
|
|
cond = (x >= point) |
|
|
accumulated_y_moment += self._moment_y[point] |
|
|
accumulated_y_load += self._load_y[point] |
|
|
self._load_y_func = Piecewise((accumulated_y_load,cond),(self._load_y_func,True)) |
|
|
self._moment_y_func = Piecewise((accumulated_y_moment,cond),(self._moment_y_func,True)) |
|
|
|
|
|
moment_A = self._moment_y_func.subs(x,self._right_support[0]).subs(x0,self._left_support[0]) +\ |
|
|
self._moment_x_func.subs(x,self._right_support[0]).subs(y,self._left_support[1]) |
|
|
|
|
|
moment_hinge_left = self._moment_y_func.subs(x,self._crown_x).subs(x0,self._crown_x) +\ |
|
|
self._moment_x_func.subs(x,self._crown_x).subs(y,self._crown_y) |
|
|
|
|
|
moment_hinge_right = self._moment_y_func.subs(x,self._right_support[0]).subs(x0,self._crown_x)- \ |
|
|
self._moment_y_func.subs(x,self._crown_x).subs(x0,self._crown_x) +\ |
|
|
self._moment_x_func.subs(x,self._right_support[0]).subs(y,self._crown_y) -\ |
|
|
self._moment_x_func.subs(x,self._crown_x).subs(y,self._crown_y) |
|
|
|
|
|
net_x = self._load_x_func.subs(x,self._right_support[0]) |
|
|
net_y = self._load_y_func.subs(x,self._right_support[0]) |
|
|
|
|
|
if (self._supports['left']=='roller' or self._supports['right']=='roller') and not self._member: |
|
|
print("member must be added if any of the supports is roller") |
|
|
return |
|
|
|
|
|
R_A_x, R_A_y, R_B_x, R_B_y, T = symbols('R_A_x R_A_y R_B_x R_B_y T') |
|
|
|
|
|
if self._supports['left'] == 'roller' and self._supports['right'] == 'roller': |
|
|
|
|
|
if self._member[2]>=max(self._left_support[1],self._right_support[1]): |
|
|
|
|
|
if net_x!=0: |
|
|
raise ValueError("net force in x direction not possible under the specified conditions") |
|
|
|
|
|
else: |
|
|
eq1 = Eq(R_A_x ,0) |
|
|
eq2 = Eq(R_B_x, 0) |
|
|
eq3 = Eq(R_A_y + R_B_y + net_y,0) |
|
|
|
|
|
eq4 = Eq(R_B_y*(self._right_support[0]-self._left_support[0])-\ |
|
|
R_B_x*(self._right_support[1]-self._left_support[1])+moment_A,0) |
|
|
|
|
|
eq5 = Eq(moment_hinge_right + R_B_y*(self._right_support[0]-self._crown_x) +\ |
|
|
T*(self._member[2]-self._crown_y),0) |
|
|
solution = solve((eq1,eq2,eq3,eq4,eq5),(R_A_x,R_A_y,R_B_x,R_B_y,T)) |
|
|
|
|
|
elif self._member[2]>=self._left_support[1]: |
|
|
eq1 = Eq(R_A_x ,0) |
|
|
eq2 = Eq(R_B_x, 0) |
|
|
eq3 = Eq(R_A_y + R_B_y + net_y,0) |
|
|
eq4 = Eq(R_B_y*(self._right_support[0]-self._left_support[0])-\ |
|
|
T*(self._member[2]-self._left_support[1])+moment_A,0) |
|
|
eq5 = Eq(T+net_x,0) |
|
|
solution = solve((eq1,eq2,eq3,eq4,eq5),(R_A_x,R_A_y,R_B_x,R_B_y,T)) |
|
|
|
|
|
elif self._member[2]>=self._right_support[1]: |
|
|
eq1 = Eq(R_A_x ,0) |
|
|
eq2 = Eq(R_B_x, 0) |
|
|
eq3 = Eq(R_A_y + R_B_y + net_y,0) |
|
|
eq4 = Eq(R_B_y*(self._right_support[0]-self._left_support[0])+\ |
|
|
T*(self._member[2]-self._left_support[1])+moment_A,0) |
|
|
eq5 = Eq(T-net_x,0) |
|
|
solution = solve((eq1,eq2,eq3,eq4,eq5),(R_A_x,R_A_y,R_B_x,R_B_y,T)) |
|
|
|
|
|
elif self._supports['left'] == 'roller': |
|
|
if self._member[2]>=max(self._left_support[1], self._right_support[1]): |
|
|
eq1 = Eq(R_A_x ,0) |
|
|
eq2 = Eq(R_B_x+net_x,0) |
|
|
eq3 = Eq(R_A_y + R_B_y + net_y,0) |
|
|
eq4 = Eq(R_B_y*(self._right_support[0]-self._left_support[0])-\ |
|
|
R_B_x*(self._right_support[1]-self._left_support[1])+moment_A,0) |
|
|
eq5 = Eq(moment_hinge_left + R_A_y*(self._left_support[0]-self._crown_x) -\ |
|
|
T*(self._member[2]-self._crown_y),0) |
|
|
solution = solve((eq1,eq2,eq3,eq4,eq5),(R_A_x,R_A_y,R_B_x,R_B_y,T)) |
|
|
|
|
|
elif self._member[2]>=self._left_support[1]: |
|
|
eq1 = Eq(R_A_x ,0) |
|
|
eq2 = Eq(R_B_x+ T +net_x,0) |
|
|
eq3 = Eq(R_A_y + R_B_y + net_y,0) |
|
|
eq4 = Eq(R_B_y*(self._right_support[0]-self._left_support[0])-\ |
|
|
R_B_x*(self._right_support[1]-self._left_support[1])-\ |
|
|
T*(self._member[2]-self._left_support[0])+moment_A,0) |
|
|
eq5 = Eq(moment_hinge_left + R_A_y*(self._left_support[0]-self._crown_x)-\ |
|
|
T*(self._member[2]-self._crown_y),0) |
|
|
solution = solve((eq1,eq2,eq3,eq4,eq5),(R_A_x,R_A_y,R_B_x,R_B_y,T)) |
|
|
|
|
|
elif self._member[2]>=self._right_support[0]: |
|
|
eq1 = Eq(R_A_x,0) |
|
|
eq2 = Eq(R_B_x- T +net_x,0) |
|
|
eq3 = Eq(R_A_y + R_B_y + net_y,0) |
|
|
eq4 = Eq(moment_hinge_left+R_A_y*(self._left_support[0]-self._crown_x),0) |
|
|
eq5 = Eq(moment_A+R_B_y*(self._right_support[0]-self._left_support[0])-\ |
|
|
R_B_x*(self._right_support[1]-self._left_support[1])+\ |
|
|
T*(self._member[2]-self._left_support[1]),0) |
|
|
solution = solve((eq1,eq2,eq3,eq4,eq5),(R_A_x,R_A_y,R_B_x,R_B_y,T)) |
|
|
|
|
|
elif self._supports['right'] == 'roller': |
|
|
if self._member[2]>=max(self._left_support[1], self._right_support[1]): |
|
|
eq1 = Eq(R_B_x,0) |
|
|
eq2 = Eq(R_A_x+net_x,0) |
|
|
eq3 = Eq(R_A_y+R_B_y+net_y,0) |
|
|
eq4 = Eq(moment_hinge_right+R_B_y*(self._right_support[0]-self._crown_x)+\ |
|
|
T*(self._member[2]-self._crown_y),0) |
|
|
eq5 = Eq(moment_A+R_B_y*(self._right_support[0]-self._left_support[0]),0) |
|
|
solution = solve((eq1,eq2,eq3,eq4,eq5),(R_A_x,R_A_y,R_B_x,R_B_y,T)) |
|
|
|
|
|
elif self._member[2]>=self._left_support[1]: |
|
|
eq1 = Eq(R_B_x,0) |
|
|
eq2 = Eq(R_A_x+T+net_x,0) |
|
|
eq3 = Eq(R_A_y+R_B_y+net_y,0) |
|
|
eq4 = Eq(moment_hinge_right+R_B_y*(self._right_support[0]-self._crown_x),0) |
|
|
eq5 = Eq(moment_A-T*(self._member[2]-self._left_support[1])+\ |
|
|
R_B_y*(self._right_support[0]-self._left_support[0]),0) |
|
|
solution = solve((eq1,eq2,eq3,eq4,eq5),(R_A_x,R_A_y,R_B_x,R_B_y,T)) |
|
|
|
|
|
elif self._member[2]>=self._right_support[1]: |
|
|
eq1 = Eq(R_B_x,0) |
|
|
eq2 = Eq(R_A_x-T+net_x,0) |
|
|
eq3 = Eq(R_A_y+R_B_y+net_y,0) |
|
|
eq4 = Eq(moment_hinge_right+R_B_y*(self._right_support[0]-self._crown_x)+\ |
|
|
T*(self._member[2]-self._crown_y),0) |
|
|
eq5 = Eq(moment_A+T*(self._member[2]-self._left_support[1])+\ |
|
|
R_B_y*(self._right_support[0]-self._left_support[0])) |
|
|
solution = solve((eq1,eq2,eq3,eq4,eq5),(R_A_x,R_A_y,R_B_x,R_B_y,T)) |
|
|
else: |
|
|
eq1 = Eq(R_A_x + R_B_x + net_x,0) |
|
|
eq2 = Eq(R_A_y + R_B_y + net_y,0) |
|
|
eq3 = Eq(R_B_y*(self._right_support[0]-self._left_support[0])-\ |
|
|
R_B_x*(self._right_support[1]-self._left_support[1])+moment_A,0) |
|
|
eq4 = Eq(moment_hinge_right + R_B_y*(self._right_support[0]-self._crown_x) -\ |
|
|
R_B_x*(self._right_support[1]-self._crown_y),0) |
|
|
solution = solve((eq1,eq2,eq3,eq4),(R_A_x,R_A_y,R_B_x,R_B_y)) |
|
|
|
|
|
for symb in self._reaction_force: |
|
|
self._reaction_force[symb] = solution[symb] |
|
|
|
|
|
self._bending_moment = - (self._moment_x_func.subs(x,x0) + self._moment_y_func.subs(x,x0) -\ |
|
|
solution[R_A_y]*(x0-self._left_support[0]) +\ |
|
|
solution[R_A_x]*(self._shape_eqn.subs({x:x0})-self._left_support[1])) |
|
|
|
|
|
angle = atan(diff(self._shape_eqn,x)) |
|
|
|
|
|
fx = (self._load_x_func+solution[R_A_x]) |
|
|
fy = (self._load_y_func+solution[R_A_y]) |
|
|
|
|
|
axial_force = fx*cos(angle) + fy*sin(angle) |
|
|
shear_force = -fx*sin(angle) + fy*cos(angle) |
|
|
|
|
|
self._axial_force = axial_force |
|
|
self._shear_force = shear_force |
|
|
|
|
|
@doctest_depends_on(modules=('numpy',)) |
|
|
def draw(self): |
|
|
""" |
|
|
This method returns a plot object containing the diagram of the specified arch along with the supports |
|
|
and forces applied to the structure. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Symbol |
|
|
>>> t = Symbol('t') |
|
|
>>> from sympy.physics.continuum_mechanics.arch import Arch |
|
|
>>> a = Arch((0,0),(40,0),crown_x=20,crown_y=12) |
|
|
>>> a.apply_load(-1,'C',8,150,angle=270) |
|
|
>>> a.apply_load(0,'D',start=20,end=40,mag=-4) |
|
|
>>> a.apply_load(-1,'E',10,t,angle=300) |
|
|
>>> p = a.draw() |
|
|
>>> p # doctest: +ELLIPSIS |
|
|
Plot object containing: |
|
|
[0]: cartesian line: 11.325 - 3*(x - 20)**2/100 for x over (0.0, 40.0) |
|
|
[1]: cartesian line: 12 - 3*(x - 20)**2/100 for x over (0.0, 40.0) |
|
|
... |
|
|
>>> p.show() |
|
|
|
|
|
""" |
|
|
x = Symbol('x') |
|
|
markers = [] |
|
|
annotations = self._draw_loads() |
|
|
rectangles = [] |
|
|
supports = self._draw_supports() |
|
|
markers+=supports |
|
|
|
|
|
xmax = self._right_support[0] |
|
|
xmin = self._left_support[0] |
|
|
ymin = min(self._left_support[1],self._right_support[1]) |
|
|
ymax = self._crown_y |
|
|
|
|
|
lim = max(xmax*1.1-xmin*0.8+1, ymax*1.1-ymin*0.8+1) |
|
|
|
|
|
rectangles = self._draw_rectangles() |
|
|
|
|
|
filler = self._draw_filler() |
|
|
rectangles+=filler |
|
|
|
|
|
if self._member is not None: |
|
|
if(self._member[2]>=self._right_support[1]): |
|
|
markers.append( |
|
|
{ |
|
|
'args':[[self._member[1]+0.005*lim],[self._member[2]]], |
|
|
'marker':'o', |
|
|
'markersize': 4, |
|
|
'color': 'white', |
|
|
'markerfacecolor':'none' |
|
|
} |
|
|
) |
|
|
|
|
|
if(self._member[2]>=self._left_support[1]): |
|
|
markers.append( |
|
|
{ |
|
|
'args':[[self._member[0]-0.005*lim],[self._member[2]]], |
|
|
'marker':'o', |
|
|
'markersize': 4, |
|
|
'color': 'white', |
|
|
'markerfacecolor':'none' |
|
|
} |
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
markers.append({ |
|
|
'args':[[self._crown_x],[self._crown_y-0.005*lim]], |
|
|
'marker':'o', |
|
|
'markersize': 5, |
|
|
'color':'white', |
|
|
'markerfacecolor':'none', |
|
|
}) |
|
|
|
|
|
if lim==xmax*1.1-xmin*0.8+1: |
|
|
|
|
|
sing_plot = plot(self._shape_eqn-0.015*lim, |
|
|
self._shape_eqn, |
|
|
(x, self._left_support[0], self._right_support[0]), |
|
|
markers=markers, |
|
|
show=False, |
|
|
annotations=annotations, |
|
|
rectangles = rectangles, |
|
|
xlim=(xmin-0.05*lim, xmax*1.1), |
|
|
ylim=(xmin-0.05*lim, xmax*1.1), |
|
|
axis=False, |
|
|
line_color='brown') |
|
|
|
|
|
else: |
|
|
sing_plot = plot(self._shape_eqn-0.015*lim, |
|
|
self._shape_eqn, |
|
|
(x, self._left_support[0], self._right_support[0]), |
|
|
markers=markers, |
|
|
show=False, |
|
|
annotations=annotations, |
|
|
rectangles = rectangles, |
|
|
xlim=(ymin-0.05*lim, ymax*1.1), |
|
|
ylim=(ymin-0.05*lim, ymax*1.1), |
|
|
axis=False, |
|
|
line_color='brown') |
|
|
|
|
|
return sing_plot |
|
|
|
|
|
|
|
|
def _draw_supports(self): |
|
|
support_markers = [] |
|
|
|
|
|
xmax = self._right_support[0] |
|
|
xmin = self._left_support[0] |
|
|
ymin = min(self._left_support[1],self._right_support[1]) |
|
|
ymax = self._crown_y |
|
|
|
|
|
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 |
|
|
|
|
|
if self._supports['left']=='roller': |
|
|
support_markers.append( |
|
|
{ |
|
|
'args':[ |
|
|
[self._left_support[0]], |
|
|
[self._left_support[1]-0.02*max_diff] |
|
|
], |
|
|
'marker':'o', |
|
|
'markersize':11, |
|
|
'color':'black', |
|
|
'markerfacecolor':'none' |
|
|
} |
|
|
) |
|
|
else: |
|
|
support_markers.append( |
|
|
{ |
|
|
'args':[ |
|
|
[self._left_support[0]], |
|
|
[self._left_support[1]-0.007*max_diff] |
|
|
], |
|
|
'marker':6, |
|
|
'markersize':15, |
|
|
'color':'black', |
|
|
'markerfacecolor':'none' |
|
|
} |
|
|
) |
|
|
|
|
|
if self._supports['right']=='roller': |
|
|
support_markers.append( |
|
|
{ |
|
|
'args':[ |
|
|
[self._right_support[0]], |
|
|
[self._right_support[1]-0.02*max_diff] |
|
|
], |
|
|
'marker':'o', |
|
|
'markersize':11, |
|
|
'color':'black', |
|
|
'markerfacecolor':'none' |
|
|
} |
|
|
) |
|
|
else: |
|
|
support_markers.append( |
|
|
{ |
|
|
'args':[ |
|
|
[self._right_support[0]], |
|
|
[self._right_support[1]-0.007*max_diff] |
|
|
], |
|
|
'marker':6, |
|
|
'markersize':15, |
|
|
'color':'black', |
|
|
'markerfacecolor':'none' |
|
|
} |
|
|
) |
|
|
|
|
|
support_markers.append( |
|
|
{ |
|
|
'args':[ |
|
|
[self._right_support[0]], |
|
|
[self._right_support[1]-0.036*max_diff] |
|
|
], |
|
|
'marker':'_', |
|
|
'markersize':15, |
|
|
'color':'black', |
|
|
'markerfacecolor':'none' |
|
|
} |
|
|
) |
|
|
|
|
|
support_markers.append( |
|
|
{ |
|
|
'args':[ |
|
|
[self._left_support[0]], |
|
|
[self._left_support[1]-0.036*max_diff] |
|
|
], |
|
|
'marker':'_', |
|
|
'markersize':15, |
|
|
'color':'black', |
|
|
'markerfacecolor':'none' |
|
|
} |
|
|
) |
|
|
|
|
|
return support_markers |
|
|
|
|
|
def _draw_rectangles(self): |
|
|
member = [] |
|
|
|
|
|
xmax = self._right_support[0] |
|
|
xmin = self._left_support[0] |
|
|
ymin = min(self._left_support[1],self._right_support[1]) |
|
|
ymax = self._crown_y |
|
|
|
|
|
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 |
|
|
|
|
|
if self._member is not None: |
|
|
if self._member[2]>= max(self._left_support[1],self._right_support[1]): |
|
|
member.append( |
|
|
{ |
|
|
'xy':(self._member[0],self._member[2]-0.005*max_diff), |
|
|
'width':self._member[1]-self._member[0], |
|
|
'height': 0.01*max_diff, |
|
|
'angle': 0, |
|
|
'color':'brown', |
|
|
} |
|
|
) |
|
|
|
|
|
elif self._member[2]>=self._left_support[1]: |
|
|
member.append( |
|
|
{ |
|
|
'xy':(self._member[0],self._member[2]-0.005*max_diff), |
|
|
'width':self._right_support[0]-self._member[0], |
|
|
'height': 0.01*max_diff, |
|
|
'angle': 0, |
|
|
'color':'brown', |
|
|
} |
|
|
) |
|
|
|
|
|
else: |
|
|
member.append( |
|
|
{ |
|
|
'xy':(self._member[1],self._member[2]-0.005*max_diff), |
|
|
'width':abs(self._left_support[0]-self._member[1]), |
|
|
'height': 0.01*max_diff, |
|
|
'angle': 180, |
|
|
'color':'brown', |
|
|
} |
|
|
) |
|
|
|
|
|
if self._distributed_loads: |
|
|
for loads in self._distributed_loads: |
|
|
|
|
|
start = self._distributed_loads[loads]['start'] |
|
|
end = self._distributed_loads[loads]['end'] |
|
|
|
|
|
member.append( |
|
|
{ |
|
|
'xy':(start,self._crown_y+max_diff*0.15), |
|
|
'width': (end-start), |
|
|
'height': max_diff*0.01, |
|
|
'color': 'orange' |
|
|
} |
|
|
) |
|
|
|
|
|
|
|
|
return member |
|
|
|
|
|
def _draw_loads(self): |
|
|
load_annotations = [] |
|
|
|
|
|
xmax = self._right_support[0] |
|
|
xmin = self._left_support[0] |
|
|
ymin = min(self._left_support[1],self._right_support[1]) |
|
|
ymax = self._crown_y |
|
|
|
|
|
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 load in self._conc_loads: |
|
|
x = self._conc_loads[load]['x'] |
|
|
y = self._conc_loads[load]['y'] |
|
|
angle = self._conc_loads[load]['angle'] |
|
|
mag = self._conc_loads[load]['mag'] |
|
|
load_annotations.append( |
|
|
{ |
|
|
'text':'', |
|
|
'xy':( |
|
|
x+cos(rad(angle))*max_diff*0.08, |
|
|
y+sin(rad(angle))*max_diff*0.08 |
|
|
), |
|
|
'xytext':(x,y), |
|
|
'fontsize':10, |
|
|
'fontweight': 'bold', |
|
|
'arrowprops':{'width':1.5, 'headlength':5, 'headwidth':5, 'facecolor':'blue','edgecolor':'blue'} |
|
|
} |
|
|
) |
|
|
load_annotations.append( |
|
|
{ |
|
|
'text':f'{load}: {mag} N', |
|
|
'fontsize':10, |
|
|
'fontweight': 'bold', |
|
|
'xy': (x+cos(rad(angle))*max_diff*0.12,y+sin(rad(angle))*max_diff*0.12) |
|
|
} |
|
|
) |
|
|
|
|
|
for load in self._distributed_loads: |
|
|
start = self._distributed_loads[load]['start'] |
|
|
end = self._distributed_loads[load]['end'] |
|
|
mag = self._distributed_loads[load]['f_y'] |
|
|
x_points = numpy.arange(start,end,(end-start)/(max_diff*0.25)) |
|
|
x_points = numpy.append(x_points,end) |
|
|
for point in x_points: |
|
|
if(mag<0): |
|
|
load_annotations.append( |
|
|
{ |
|
|
'text':'', |
|
|
'xy':(point,self._crown_y+max_diff*0.05), |
|
|
'xytext': (point,self._crown_y+max_diff*0.15), |
|
|
'arrowprops':{'width':1.5, 'headlength':5, 'headwidth':5, 'facecolor':'orange','edgecolor':'orange'} |
|
|
} |
|
|
) |
|
|
else: |
|
|
load_annotations.append( |
|
|
{ |
|
|
'text':'', |
|
|
'xy':(point,self._crown_y+max_diff*0.2), |
|
|
'xytext': (point,self._crown_y+max_diff*0.15), |
|
|
'arrowprops':{'width':1.5, 'headlength':5, 'headwidth':5, 'facecolor':'orange','edgecolor':'orange'} |
|
|
} |
|
|
) |
|
|
if(mag<0): |
|
|
load_annotations.append( |
|
|
{ |
|
|
'text':f'{load}: {abs(mag)} N/m', |
|
|
'fontsize':10, |
|
|
'fontweight': 'bold', |
|
|
'xy':((start+end)/2,self._crown_y+max_diff*0.175) |
|
|
} |
|
|
) |
|
|
else: |
|
|
load_annotations.append( |
|
|
{ |
|
|
'text':f'{load}: {abs(mag)} N/m', |
|
|
'fontsize':10, |
|
|
'fontweight': 'bold', |
|
|
'xy':((start+end)/2,self._crown_y+max_diff*0.125) |
|
|
} |
|
|
) |
|
|
return load_annotations |
|
|
|
|
|
def _draw_filler(self): |
|
|
x = Symbol('x') |
|
|
filler = [] |
|
|
xmax = self._right_support[0] |
|
|
xmin = self._left_support[0] |
|
|
ymin = min(self._left_support[1],self._right_support[1]) |
|
|
ymax = self._crown_y |
|
|
|
|
|
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 |
|
|
|
|
|
x_points = numpy.arange(self._left_support[0],self._right_support[0],(self._right_support[0]-self._left_support[0])/(max_diff*max_diff)) |
|
|
|
|
|
for point in x_points: |
|
|
filler.append( |
|
|
{ |
|
|
'xy':(point,self._shape_eqn.subs(x,point)-max_diff*0.015), |
|
|
'width': (self._right_support[0]-self._left_support[0])/(max_diff*max_diff), |
|
|
'height': max_diff*0.015, |
|
|
'color': 'brown' |
|
|
} |
|
|
) |
|
|
|
|
|
return filler |
|
|
|
