o o hQ@sbdZddlmZmZmZmZddlmZddlm Z ddl m Z m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZddlm Z ddl!m"Z"ddl#m$Z$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl2Z2ddgiZ3e)dddgidZ4GdddZ5Gd d!d!e5Z6dS)"zd This module can be used to solve 2D beam bending problems with singularity functions in mechanics. )SSymboldiffsymbols)Add)Expr) DerivativeFunction)Mul)Eqsympify)linsolve)dsolve)solve)sstr)SingularityFunction Piecewise factorial integrate)limit)plotPlotGrid)GeometryEntity) import_module)Interval)lambdify)doctest_depends_on)iterableN) Beam.drawBeam.plot_bending_momentBeam.plot_deflectionBeam.plot_ild_momentBeam.plot_ild_shearBeam.plot_shear_forceBeam.plot_shear_stressBeam.plot_slope matplotlibnumpyfromlistarange) import_kwargsc@seZdZdZededdfddZddZed d Zed d Z ed dZ eddZ eddZ e j ddZ eddZej ddZeddZej ddZeddZej ddZeddZej ddZed d!Zej d"d!Zed#d$Zed%d&Zej d'd&Zed(d)Zej d*d)Zdvd,d-Zdvd.d/Zdwd1d2Zdwd3d4Zd5d6Zed7d8Zed9d:Zd;d<Zd=d>Zd?d@ZdAdBZ dCdDZ!dEdFZ"dGdHZ#dIdJZ$dKdLZ%dMdNZ&dOdPZ'dwdQdRZ(dwdSdTZ)dwdUdVZ*dwdWdXZ+dwdYdZZ,dwd[d\Z-d]d^Z.d_d`Z/dwdadbZ0dcddZ1dwdedfZ2dgdhZ3dwdidjZ4e5dkdldxdndoZ6dpdqZ7drdsZ8dtduZ9d0S)yBeamaO A Beam is a structural element that is capable of withstanding load primarily by resisting against bending. Beams are characterized by their cross sectional profile(Second moment of area), their length and their material. .. note:: A consistent sign convention must be used while solving a beam bending problem; the results will automatically follow the chosen sign convention. However, the chosen sign convention must respect the rule that, on the positive side of beam's axis (in respect to current section), a loading force giving positive shear yields a negative moment, as below (the curved arrow shows the positive moment and rotation): .. image:: allowed-sign-conventions.png Examples ======== There is a beam of length 4 meters. A constant distributed load of 6 N/m is applied from half of the beam till the end. There are two simple supports below the beam, one at the starting point and another at the ending point of the beam. The deflection of the beam at the end is restricted. Using the sign convention of downwards forces being positive. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols, Piecewise >>> E, I = symbols('E, I') >>> R1, R2 = symbols('R1, R2') >>> b = Beam(4, E, I) >>> b.apply_load(R1, 0, -1) >>> b.apply_load(6, 2, 0) >>> b.apply_load(R2, 4, -1) >>> b.bc_deflection = [(0, 0), (4, 0)] >>> b.boundary_conditions {'deflection': [(0, 0), (4, 0)], 'slope': []} >>> b.load R1*SingularityFunction(x, 0, -1) + R2*SingularityFunction(x, 4, -1) + 6*SingularityFunction(x, 2, 0) >>> b.solve_for_reaction_loads(R1, R2) >>> b.load -3*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 2, 0) - 9*SingularityFunction(x, 4, -1) >>> b.shear_force() 3*SingularityFunction(x, 0, 0) - 6*SingularityFunction(x, 2, 1) + 9*SingularityFunction(x, 4, 0) >>> b.bending_moment() 3*SingularityFunction(x, 0, 1) - 3*SingularityFunction(x, 2, 2) + 9*SingularityFunction(x, 4, 1) >>> b.slope() (-3*SingularityFunction(x, 0, 2)/2 + SingularityFunction(x, 2, 3) - 9*SingularityFunction(x, 4, 2)/2 + 7)/(E*I) >>> b.deflection() (7*x - SingularityFunction(x, 0, 3)/2 + SingularityFunction(x, 2, 4)/4 - 3*SingularityFunction(x, 4, 3)/2)/(E*I) >>> b.deflection().rewrite(Piecewise) (7*x - Piecewise((x**3, x >= 0), (0, True))/2 - 3*Piecewise(((x - 4)**3, x >= 4), (0, True))/2 + Piecewise(((x - 2)**4, x >= 2), (0, True))/4)/(E*I) Calculate the support reactions for a fully symbolic beam of length L. There are two simple supports below the beam, one at the starting point and another at the ending point of the beam. The deflection of the beam at the end is restricted. The beam is loaded with: * a downward point load P1 applied at L/4 * an upward point load P2 applied at L/8 * a counterclockwise moment M1 applied at L/2 * a clockwise moment M2 applied at 3*L/4 * a distributed constant load q1, applied downward, starting from L/2 up to 3*L/4 * a distributed constant load q2, applied upward, starting from 3*L/4 up to L No assumptions are needed for symbolic loads. However, defining a positive length will help the algorithm to compute the solution. >>> E, I = symbols('E, I') >>> L = symbols("L", positive=True) >>> P1, P2, M1, M2, q1, q2 = symbols("P1, P2, M1, M2, q1, q2") >>> R1, R2 = symbols('R1, R2') >>> b = Beam(L, E, I) >>> b.apply_load(R1, 0, -1) >>> b.apply_load(R2, L, -1) >>> b.apply_load(P1, L/4, -1) >>> b.apply_load(-P2, L/8, -1) >>> b.apply_load(M1, L/2, -2) >>> b.apply_load(-M2, 3*L/4, -2) >>> b.apply_load(q1, L/2, 0, 3*L/4) >>> b.apply_load(-q2, 3*L/4, 0, L) >>> b.bc_deflection = [(0, 0), (L, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> print(b.reaction_loads[R1]) (-3*L**2*q1 + L**2*q2 - 24*L*P1 + 28*L*P2 - 32*M1 + 32*M2)/(32*L) >>> print(b.reaction_loads[R2]) (-5*L**2*q1 + 7*L**2*q2 - 8*L*P1 + 4*L*P2 + 32*M1 - 32*M2)/(32*L) AxCcCs||_||_t|tr||_nd|_||_||_||_ggd|_d|_ ||_ g|_ g|_ g|_ i|_i|_d|_d|_d|_d|_d|_dS)aInitializes the class. Parameters ========== length : Sympifyable A Symbol or value representing the Beam's length. elastic_modulus : Sympifyable A SymPy expression representing the Beam's Modulus of Elasticity. It is a measure of the stiffness of the Beam material. It can also be a continuous function of position along the beam. second_moment : Sympifyable or Geometry object Describes the cross-section of the beam via a SymPy expression representing the Beam's second moment of area. It is a geometrical property of an area which reflects how its points are distributed with respect to its neutral axis. It can also be a continuous function of position along the beam. Alternatively ``second_moment`` can be a shape object such as a ``Polygon`` from the geometry module representing the shape of the cross-section of the beam. In such cases, it is assumed that the x-axis of the shape object is aligned with the bending axis of the beam. The second moment of area will be computed from the shape object internally. area : Symbol/float Represents the cross-section area of beam variable : Symbol, optional A Symbol object that will be used as the variable along the beam while representing the load, shear, moment, slope and deflection curve. By default, it is set to ``Symbol('x')``. base_char : String, optional A String that will be used as base character to generate sequential symbols for integration constants in cases where boundary conditions are not sufficient to solve them. N) deflectionsloper)lengthelastic_modulus isinstancer cross_section second_momentvariable _base_char_boundary_conditions_loadarea_applied_supports_support_as_loads_applied_loads_reaction_loads_ild_reactions _ild_shear _ild_moment_original_load_composite_type_hinge_position)selfr3r4r7r<r8 base_charrIz/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/physics/continuum_mechanics/beam.py__init__s*'   z Beam.__init__cCs4|jr|jn|j}dt|jt|jt|}|S)NzBeam({}, {}, {}))_cross_section_second_momentformatr_length_elastic_modulus)rGshape_descriptionstr_solrIrIrJ__str__sz Beam.__str__cC|jS)z- Returns the reaction forces in a dictionary.)r@rGrIrIrJreaction_loadszBeam.reaction_loadscCrT)z# Returns the I.L.D. shear equation.)rBrUrIrIrJ ild_shearrWzBeam.ild_shearcCrT)z4 Returns the I.L.D. reaction forces in a dictionary.)rArUrIrIrJ ild_reactionsrWzBeam.ild_reactionscCrT)z$ Returns the I.L.D. moment equation.)rCrUrIrIrJ ild_momentrWzBeam.ild_momentcCrT)zLength of the Beam.)rOrUrIrIrJr3rWz Beam.lengthcCt||_dSN)r rO)rGlrIrIrJr3cCrTz"Cross-sectional area of the Beam. _arearUrIrIrJr<rWz Beam.areacCr[r\r rarGarIrIrJr<r^cCrT)a A symbol that can be used as a variable along the length of the beam while representing load distribution, shear force curve, bending moment, slope curve and the deflection curve. By default, it is set to ``Symbol('x')``, but this property is mutable. Examples ======== >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I, A = symbols('E, I, A') >>> x, y, z = symbols('x, y, z') >>> b = Beam(4, E, I) >>> b.variable x >>> b.variable = y >>> b.variable y >>> b = Beam(4, E, I, A, z) >>> b.variable z ) _variablerUrIrIrJr8z Beam.variablecCst|tr ||_dStd)Nz'The variable should be a Symbol object.)r5rre TypeError)rGvrIrIrJr8s  cCrTzYoung's Modulus of the Beam. )rPrUrIrIrJr4rWzBeam.elastic_moduluscCr[r\)r rPrGerIrIrJr4r^cCrTz#Second moment of area of the Beam. rMrUrIrIrJr7!rWzBeam.second_momentcCs&d|_t|tr tdt||_dS)Nz>To update cross-section geometry use `cross_section` attribute)rLr5r ValueErrorr rMrGirIrIrJr7&s cCrT)zCross-section of the beam)rLrUrIrIrJr6.rWzBeam.cross_sectioncCs|r |d|_||_dS)Nr)second_moment_of_arearMrL)rGsrIrIrJr63s cCrT)a Returns a dictionary of boundary conditions applied on the beam. The dictionary has three keywords namely moment, slope and deflection. The value of each keyword is a list of tuple, where each tuple contains location and value of a boundary condition in the format (location, value). Examples ======== There is a beam of length 4 meters. The bending moment at 0 should be 4 and at 4 it should be 0. The slope of the beam should be 1 at 0. The deflection should be 2 at 0. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> b = Beam(4, E, I) >>> b.bc_deflection = [(0, 2)] >>> b.bc_slope = [(0, 1)] >>> b.boundary_conditions {'deflection': [(0, 2)], 'slope': [(0, 1)]} Here the deflection of the beam should be ``2`` at ``0``. Similarly, the slope of the beam should be ``1`` at ``0``. r:rUrIrIrJboundary_conditions9szBeam.boundary_conditionscC |jdSNr2rsrUrIrIrJbc_slopeV z Beam.bc_slopecC||jd<dSrvrs)rGs_bcsrIrIrJrwZr^cCruNr1rsrUrIrIrJ bc_deflection^rxzBeam.bc_deflectioncCryr{rs)rGd_bcsrIrIrJr|br^fixedcCs|j}|j}|j|j}|j|jkr#t|j||jkf|j||kf}n|j}|dkr6t||||}d|_|S|dkrJt||||}d|_|j|_|SdS)a This method joins two beams to make a new composite beam system. Passed Beam class instance is attached to the right end of calling object. This method can be used to form beams having Discontinuous values of Elastic modulus or Second moment. Parameters ========== beam : Beam class object The Beam object which would be connected to the right of calling object. via : String States the way two Beam object would get connected - For axially fixed Beams, via="fixed" - For Beams connected via hinge, via="hinge" Examples ======== There is a cantilever beam of length 4 meters. For first 2 meters its moment of inertia is `1.5*I` and `I` for the other end. A pointload of magnitude 4 N is applied from the top at its free end. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> R1, R2 = symbols('R1, R2') >>> b1 = Beam(2, E, 1.5*I) >>> b2 = Beam(2, E, I) >>> b = b1.join(b2, "fixed") >>> b.apply_load(20, 4, -1) >>> b.apply_load(R1, 0, -1) >>> b.apply_load(R2, 0, -2) >>> b.bc_slope = [(0, 0)] >>> b.bc_deflection = [(0, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.load 80*SingularityFunction(x, 0, -2) - 20*SingularityFunction(x, 0, -1) + 20*SingularityFunction(x, 4, -1) >>> b.slope() (-((-80*SingularityFunction(x, 0, 1) + 10*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 4, 2))/I + 120/I)/E + 80.0/(E*I))*SingularityFunction(x, 2, 0) - 0.666666666666667*(-80*SingularityFunction(x, 0, 1) + 10*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 4, 2))*SingularityFunction(x, 0, 0)/(E*I) + 0.666666666666667*(-80*SingularityFunction(x, 0, 1) + 10*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 4, 2))*SingularityFunction(x, 2, 0)/(E*I) r~hingeN)r8r4r3r7rr-rErF)rGbeamviar/E new_lengthnew_second_momentnew_beamrIrIrJjoinfs$+   z Beam.joincCst|}|j||f|dvr(tdt|}|||d|j|dfn8tdt|}tdt|}|||d|||d|j|df|j|df|j||ddf|j||ddf|dvrp|S||fS)a This method applies support to a particular beam object and returns the symbol of the unknown reaction load(s). Parameters ========== loc : Sympifyable Location of point at which support is applied. type : String Determines type of Beam support applied. To apply support structure with - zero degree of freedom, type = "fixed" - one degree of freedom, type = "pin" - two degrees of freedom, type = "roller" Returns ======= Symbol or tuple of Symbol The unknown reaction load as a symbol. - Symbol(reaction_force) if type = "pin" or "roller" - Symbol(reaction_force), Symbol(reaction_moment) if type = "fixed" Examples ======== There is a beam of length 20 meters. A moment of magnitude 100 Nm is applied in the clockwise direction at the end of the beam. A pointload of magnitude 8 N is applied from the top of the beam at a distance of 10 meters. There is one fixed support at the start of the beam and a roller at the end. Using the sign convention of upward forces and clockwise moment being positive. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> b = Beam(20, E, I) >>> p0, m0 = b.apply_support(0, 'fixed') >>> p1 = b.apply_support(20, 'roller') >>> b.apply_load(-8, 10, -1) >>> b.apply_load(100, 20, -2) >>> b.solve_for_reaction_loads(p0, m0, p1) >>> b.reaction_loads {M_0: 20, R_0: -2, R_20: 10} >>> b.reaction_loads[p0] -2 >>> b.load 20*SingularityFunction(x, 0, -2) - 2*SingularityFunction(x, 0, -1) - 8*SingularityFunction(x, 10, -1) + 100*SingularityFunction(x, 20, -2) + 10*SingularityFunction(x, 20, -1) pinrollerR_rM_N) r r=appendrstr apply_loadr|rwr>rGloctype reaction_loadreaction_momentrIrIrJ apply_supports"3zBeam.apply_supportNcCs|j}t|}t|}t|}|j||||f|j|t|||7_|j|t|||7_|rB|j|||||dddSdS)a This method adds up the loads given to a particular beam object. Parameters ========== value : Sympifyable The value inserted should have the units [Force/(Distance**(n+1)] where n is the order of applied load. Units for applied loads: - For moments, unit = kN*m - For point loads, unit = kN - For constant distributed load, unit = kN/m - For ramp loads, unit = kN/m/m - For parabolic ramp loads, unit = kN/m/m/m - ... so on. start : Sympifyable The starting point of the applied load. For point moments and point forces this is the location of application. order : Integer The order of the applied load. - For moments, order = -2 - For point loads, order =-1 - For constant distributed load, order = 0 - For ramp loads, order = 1 - For parabolic ramp loads, order = 2 - ... so on. end : Sympifyable, optional An optional argument that can be used if the load has an end point within the length of the beam. Examples ======== There is a beam of length 4 meters. A moment of magnitude 3 Nm is applied in the clockwise direction at the starting point of the beam. A point load of magnitude 4 N is applied from the top of the beam at 2 meters from the starting point and a parabolic ramp load of magnitude 2 N/m is applied below the beam starting from 2 meters to 3 meters away from the starting point of the beam. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> b = Beam(4, E, I) >>> b.apply_load(-3, 0, -2) >>> b.apply_load(4, 2, -1) >>> b.apply_load(-2, 2, 2, end=3) >>> b.load -3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) - 2*SingularityFunction(x, 2, 2) + 2*SingularityFunction(x, 3, 0) + 4*SingularityFunction(x, 3, 1) + 2*SingularityFunction(x, 3, 2) applyrN)r8r r?rr;rrD _handle_end)rGvaluestartorderendr/rIrIrJrs7zBeam.apply_loadcCs|j}t|}t|}t|}||||f|jvr=|j|t|||8_|j|t|||8_|j||||fnd}t||rR|j|||||dddSdS)a This method removes a particular load present on the beam object. Returns a ValueError if the load passed as an argument is not present on the beam. Parameters ========== value : Sympifyable The magnitude of an applied load. start : Sympifyable The starting point of the applied load. For point moments and point forces this is the location of application. order : Integer The order of the applied load. - For moments, order= -2 - For point loads, order=-1 - For constant distributed load, order=0 - For ramp loads, order=1 - For parabolic ramp loads, order=2 - ... so on. end : Sympifyable, optional An optional argument that can be used if the load has an end point within the length of the beam. Examples ======== There is a beam of length 4 meters. A moment of magnitude 3 Nm is applied in the clockwise direction at the starting point of the beam. A pointload of magnitude 4 N is applied from the top of the beam at 2 meters from the starting point and a parabolic ramp load of magnitude 2 N/m is applied below the beam starting from 2 meters to 3 meters away from the starting point of the beam. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> b = Beam(4, E, I) >>> b.apply_load(-3, 0, -2) >>> b.apply_load(4, 2, -1) >>> b.apply_load(-2, 2, 2, end=3) >>> b.load -3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) - 2*SingularityFunction(x, 2, 2) + 2*SingularityFunction(x, 3, 0) + 4*SingularityFunction(x, 3, 1) + 2*SingularityFunction(x, 3, 2) >>> b.remove_load(-2, 2, 2, end = 3) >>> b.load -3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) z4No such load distribution exists on the beam object.removerN) r8r r?r;rrDrrnr)rGrrrrr/msgrIrIrJ remove_load2s/zBeam.remove_loadc Cs:|jr d}t||||}|dkrUtd|dD]8} |j||| |||t||| t| 8_|j||| |||t||| t| 8_qdS|dkrtd|dD]:} |j||| |||t||| t| 7_|j||| |||t||| t| 7_q`dSdS)z This functions handles the optional `end` value in the `apply_load` and `remove_load` functions. When the value of end is not NULL, this function will be executed. zpIf 'end' is provided the 'order' of the load cannot be negative, i.e. 'end' is only valid for distributed loads.rrrN) is_negativernranger;rsubsrrrD) rGr/rrrrrrfrprIrIrJrrs>       zBeam._handle_endcCrT)a Returns a Singularity Function expression which represents the load distribution curve of the Beam object. Examples ======== There is a beam of length 4 meters. A moment of magnitude 3 Nm is applied in the clockwise direction at the starting point of the beam. A point load of magnitude 4 N is applied from the top of the beam at 2 meters from the starting point and a parabolic ramp load of magnitude 2 N/m is applied below the beam starting from 3 meters away from the starting point of the beam. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> b = Beam(4, E, I) >>> b.apply_load(-3, 0, -2) >>> b.apply_load(4, 2, -1) >>> b.apply_load(-2, 3, 2) >>> b.load -3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) - 2*SingularityFunction(x, 3, 2) )r;rUrIrIrJloadrfz Beam.loadcCrT)a Returns a list of all loads applied on the beam object. Each load in the list is a tuple of form (value, start, order, end). Examples ======== There is a beam of length 4 meters. A moment of magnitude 3 Nm is applied in the clockwise direction at the starting point of the beam. A pointload of magnitude 4 N is applied from the top of the beam at 2 meters from the starting point. Another pointload of magnitude 5 N is applied at same position. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> b = Beam(4, E, I) >>> b.apply_load(-3, 0, -2) >>> b.apply_load(4, 2, -1) >>> b.apply_load(5, 2, -1) >>> b.load -3*SingularityFunction(x, 0, -2) + 9*SingularityFunction(x, 2, -1) >>> b.applied_loads [(-3, 0, -2, None), (4, 2, -1, None), (5, 2, -1, None)] )r?rUrIrIrJ applied_loadsszBeam.applied_loadsc! Gs|j}|j}|j}|j}t|tr |jdd}|jdd}n|}}d}d} |jD]} | d|kr}|| dt|| d| d7}| ddkrZ|| dt|| d| d8}q+| ddkr||| dt|| d| d| dt|| dd8}q+| d|kr|| dt|| d| d7}| | dt|| d|| d7} q+| d|kr| | dt|| d|| d7} | ddkr| | dt|| d|| d8} q+| ddkr| | dt|| d|| d| dt|| d|d8} q+t d} || t||d7}| | t|dd8} g} t ||} t | ||}| |t | |}t |||}| |t | |}t |||j |}| |t ||}t |||j |}| |t d}t d}t d }t d }tj||t |||}tj||t |||||||}tj||t t t | ||||}tj||t |||||}|jD]$\}}||kr| ||||q| |||||q|jD]$\}}||kr| ||||q| |||||q| |||||dtt| ||||| g|R}t|dd d } tt|| |_|j|j|_|||dd| |dd i|j}|||dd||dd| |dd i|j}||||||dd| |dd i|j}||||||dd||dd| |dd i|j}|t|dd|t||d|t||d|_|t|dd|t||d|t||d|_d S)a5 Method to find integration constants and reactional variables in a composite beam connected via hinge. This method resolves the composite Beam into its sub-beams and then equations of shear force, bending moment, slope and deflection are evaluated for both of them separately. These equations are then solved for unknown reactions and integration constants using the boundary conditions applied on the Beam. Equal deflection of both sub-beams at the hinge joint gives us another equation to solve the system. Examples ======== A combined beam, with constant fkexural rigidity E*I, is formed by joining a Beam of length 2*l to the right of another Beam of length l. The whole beam is fixed at both of its both end. A point load of magnitude P is also applied from the top at a distance of 2*l from starting point. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> l=symbols('l', positive=True) >>> b1=Beam(l, E, I) >>> b2=Beam(2*l, E, I) >>> b=b1.join(b2,"hinge") >>> M1, A1, M2, A2, P = symbols('M1 A1 M2 A2 P') >>> b.apply_load(A1,0,-1) >>> b.apply_load(M1,0,-2) >>> b.apply_load(P,2*l,-1) >>> b.apply_load(A2,3*l,-1) >>> b.apply_load(M2,3*l,-2) >>> b.bc_slope=[(0,0), (3*l, 0)] >>> b.bc_deflection=[(0,0), (3*l, 0)] >>> b.solve_for_reaction_loads(M1, A1, M2, A2) >>> b.reaction_loads {A1: -5*P/18, A2: -13*P/18, M1: 5*P*l/18, M2: -4*P*l/9} >>> b.slope() (5*P*l*SingularityFunction(x, 0, 1)/18 - 5*P*SingularityFunction(x, 0, 2)/36 + 5*P*SingularityFunction(x, l, 2)/36)*SingularityFunction(x, 0, 0)/(E*I) - (5*P*l*SingularityFunction(x, 0, 1)/18 - 5*P*SingularityFunction(x, 0, 2)/36 + 5*P*SingularityFunction(x, l, 2)/36)*SingularityFunction(x, l, 0)/(E*I) + (P*l**2/18 - 4*P*l*SingularityFunction(-l + x, 2*l, 1)/9 - 5*P*SingularityFunction(-l + x, 0, 2)/36 + P*SingularityFunction(-l + x, l, 2)/2 - 13*P*SingularityFunction(-l + x, 2*l, 2)/36)*SingularityFunction(x, l, 0)/(E*I) >>> b.deflection() (5*P*l*SingularityFunction(x, 0, 2)/36 - 5*P*SingularityFunction(x, 0, 3)/108 + 5*P*SingularityFunction(x, l, 3)/108)*SingularityFunction(x, 0, 0)/(E*I) - (5*P*l*SingularityFunction(x, 0, 2)/36 - 5*P*SingularityFunction(x, 0, 3)/108 + 5*P*SingularityFunction(x, l, 3)/108)*SingularityFunction(x, l, 0)/(E*I) + (5*P*l**3/54 + P*l**2*(-l + x)/18 - 2*P*l*SingularityFunction(-l + x, 2*l, 2)/9 - 5*P*SingularityFunction(-l + x, 0, 3)/108 + P*SingularityFunction(-l + x, l, 3)/6 - 13*P*SingularityFunction(-l + x, 2*l, 3)/108)*SingularityFunction(x, l, 0)/(E*I) rrhrC1C2C3C4N)r8rFrPrMr5rargsrrrrrrr3rOnerwrr|listrdictzipr@r;_hinge_beam_slope_hinge_beam_deflection)!rG reactionsr/r]rII1I2load_1load_2rreqshear_1 shear_curve_1 bending_1moment_curve_1shear_2 shear_curve_2 bending_2moment_curve_2rrrrslope_1def_1slope_2def_2positionr constantsreaction_valuesrIrIrJ_solve_hinge_beamss.     " 8  & $ & @          ,($  *62>26zBeam._solve_hinge_beamscGs,|jdkr |j|S|j}|j}td}td}t|||}t|||}g}g} t|||} |j dD]\} } | || | } | | q:t| ||}|j dD]\} } | || | } | | qXt t ||g|| ||f|jd}|dd}tt|||_|j |j|_dS) a Solves for the reaction forces. Examples ======== There is a beam of length 30 meters. A moment of magnitude 120 Nm is applied in the clockwise direction at the end of the beam. A pointload of magnitude 8 N is applied from the top of the beam at the starting point. There are two simple supports below the beam. One at the end and another one at a distance of 10 meters from the start. The deflection is restricted at both the supports. Using the sign convention of upward forces and clockwise moment being positive. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> R1, R2 = symbols('R1, R2') >>> b = Beam(30, E, I) >>> b.apply_load(-8, 0, -1) >>> b.apply_load(R1, 10, -1) # Reaction force at x = 10 >>> b.apply_load(R2, 30, -1) # Reaction force at x = 30 >>> b.apply_load(120, 30, -2) >>> b.bc_deflection = [(10, 0), (30, 0)] >>> b.load R1*SingularityFunction(x, 10, -1) + R2*SingularityFunction(x, 30, -1) - 8*SingularityFunction(x, 0, -1) + 120*SingularityFunction(x, 30, -2) >>> b.solve_for_reaction_loads(R1, R2) >>> b.reaction_loads {R1: 6, R2: 2} >>> b.load -8*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 10, -1) + 120*SingularityFunction(x, 30, -2) + 2*SingularityFunction(x, 30, -1) rrrr2r1rrN)rErr8r3rr shear_forcebending_momentrr:rrrrrrrr@r;)rGrr/r]rr shear_curve moment_curve slope_eqsdeflection_eqs slope_curverreqsdeflection_curvesolutionrIrIrJsolve_for_reaction_loadsPs8 $     zBeam.solve_for_reaction_loadscCs|j}t|j| S)a) Returns a Singularity Function expression which represents the shear force curve of the Beam object. Examples ======== There is a beam of length 30 meters. A moment of magnitude 120 Nm is applied in the clockwise direction at the end of the beam. A pointload of magnitude 8 N is applied from the top of the beam at the starting point. There are two simple supports below the beam. One at the end and another one at a distance of 10 meters from the start. The deflection is restricted at both the supports. Using the sign convention of upward forces and clockwise moment being positive. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> R1, R2 = symbols('R1, R2') >>> b = Beam(30, E, I) >>> b.apply_load(-8, 0, -1) >>> b.apply_load(R1, 10, -1) >>> b.apply_load(R2, 30, -1) >>> b.apply_load(120, 30, -2) >>> b.bc_deflection = [(10, 0), (30, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.shear_force() 8*SingularityFunction(x, 0, 0) - 6*SingularityFunction(x, 10, 0) - 120*SingularityFunction(x, 30, -1) - 2*SingularityFunction(x, 30, 0) )r8rrrGr/rIrIrJrzBeam.shear_forcec Cs0|}|j}|j}g}|D]}t|tr|jd}||jdqtt|}|g}g}t |D]\}} | dkr>q5zkt t d|||dkf|j t || kft ddf} t| |} g} | D] } | t||| qd| ||d| g| tt||||ddtt||| dg7} t| }|||| | |Wq5tyt||||dd}t||| d}||||d| d||dkr||kr|||g|||d| gn|||t||d| Yq5wttt|}t|}|||} | |fS zJReturns maximum Shear force and its coordinate in the Beam object.rrrnanT+-r)rr8rr5r rrsetsort enumeraterfloatr;rewriterabsrextendrmaxindexNotImplementedErrorrmap)rGrr/terms singularityterm intervals shear_valuesrprr shear_slopepointsvalpoint max_shear initial_shear final_shear maximum_shearrIrIrJmax_shear_forcesP   8 0 0  zBeam.max_shear_forcecCs|j}t||S)a. Returns a Singularity Function expression which represents the bending moment curve of the Beam object. Examples ======== There is a beam of length 30 meters. A moment of magnitude 120 Nm is applied in the clockwise direction at the end of the beam. A pointload of magnitude 8 N is applied from the top of the beam at the starting point. There are two simple supports below the beam. One at the end and another one at a distance of 10 meters from the start. The deflection is restricted at both the supports. Using the sign convention of upward forces and clockwise moment being positive. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> R1, R2 = symbols('R1, R2') >>> b = Beam(30, E, I) >>> b.apply_load(-8, 0, -1) >>> b.apply_load(R1, 10, -1) >>> b.apply_load(R2, 30, -1) >>> b.apply_load(120, 30, -2) >>> b.bc_deflection = [(10, 0), (30, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.bending_moment() 8*SingularityFunction(x, 0, 1) - 6*SingularityFunction(x, 10, 1) - 120*SingularityFunction(x, 30, 0) - 2*SingularityFunction(x, 30, 1) )r8rrrrIrIrJrrzBeam.bending_momentc Cs2|}|j}|j}g}|D]}t|tr|jd}||jdqtt|}|g}g}t |D]\}} | dkr>q5zlt t d|||dkf| t || kft ddf} t| |} g} | D] } | t||| qe| ||d| g| tt||||ddtt||| dg7} t| }|||| | |Wq5tyt||||dd}t||| d}||||d| d||dkr||kr|||g|||d| gn|||t||d| Yq5wttt|}t|}|||} | |fSr)rr8rr5r rrrrrrrrrrrrrrrrrrr)rG bending_curver/rrrr moment_valuesrprr moment_sloperrr max_momentinitial_moment final_momentmaximum_momentrIrIrJ max_bmoment sX     0 0  zBeam.max_bmomentcCsNttd|jdkf||j|jkftddf}t|t|jtjd}|S)a Returns a Set of point(s) with zero bending moment and where bending moment curve of the beam object changes its sign from negative to positive or vice versa. Examples ======== There is is 10 meter long overhanging beam. There are two simple supports below the beam. One at the start and another one at a distance of 6 meters from the start. Point loads of magnitude 10KN and 20KN are applied at 2 meters and 4 meters from start respectively. A Uniformly distribute load of magnitude of magnitude 3KN/m is also applied on top starting from 6 meters away from starting point till end. Using the sign convention of upward forces and clockwise moment being positive. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> b = Beam(10, E, I) >>> b.apply_load(-4, 0, -1) >>> b.apply_load(-46, 6, -1) >>> b.apply_load(10, 2, -1) >>> b.apply_load(20, 4, -1) >>> b.apply_load(3, 6, 0) >>> b.point_cflexure() [10/3] rrTdomain) rrr8rr3rrrReals)rGrrrIrIrJpoint_cflexure?s! zBeam.point_cflexurecCs|j}|j}|j}|jdkr|jS|jdst||St|t r|jdkr|j }d}d}d}t t |D]f}|dkrG||ddj d}t j |t|||d|||f} |t |dkr||| t||d|| t|||dj dd7}n ||| t||d7}| |||dj d}q6|Std} tt j|||| | } g} |jdD]\} }| || |}| |qtt| | }| | |ddi} | S)aD Returns a Singularity Function expression which represents the slope the elastic curve of the Beam object. Examples ======== There is a beam of length 30 meters. A moment of magnitude 120 Nm is applied in the clockwise direction at the end of the beam. A pointload of magnitude 8 N is applied from the top of the beam at the starting point. There are two simple supports below the beam. One at the end and another one at a distance of 10 meters from the start. The deflection is restricted at both the supports. Using the sign convention of upward forces and clockwise moment being positive. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> R1, R2 = symbols('R1, R2') >>> b = Beam(30, E, I) >>> b.apply_load(-8, 0, -1) >>> b.apply_load(R1, 10, -1) >>> b.apply_load(R2, 30, -1) >>> b.apply_load(120, 30, -2) >>> b.bc_deflection = [(10, 0), (30, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.slope() (-4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2) + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + 4000/3)/(E*I) rr2r~rrr)r8r4r7rErr:rr1r5rrrlenrrrrrrrrrr)rGr/rrrr2 prev_slopeprev_endrp slope_valuerrbc_eqsrrrrrIrIrJr2hs@   , " z Beam.slopecCs|j}|j}|j}|jdkr|jS|jds|jdst|tr|jdkr|j}d}d}d}d}t t |D]} | dkrG|| ddjd}t j |t ||| d|||f} || } t | |||f} | t |dkr||| t||d|| t||| djdd7}n ||| t||d7}| ||| djd}| ||| djd}q6|S|j} t| d}t j ||t t || ||d||dS|jds|j} t| d}t |||S|jds|jdrt|tr|jdkr|j}d}d}d}d}t t |D]} | dkr/|| ddjd}t j |t ||| d|||f} || } t | |||f} | t |dkrx||| t||d|| t||| djdd7}n ||| t||d7}| ||| djd}| ||| djd}q|S|j} t| d\}}t || |}t |||}g}|jdD]\}}||||}||qtt|||f}|||dd||ddi}t j |||St|tr|jdkr|j}d}d}d}d}t t |D]} | dkr*|| ddjd}t j |t ||| d|||f} || } t | |||f} | t |dkrr||| t||d|| t||| djdd7}n ||| t||d7}| ||| djd}| ||| djd}q|Std }t |||}g}|jdD]\}}||||}||qtt||}|||ddi}|S) aW Returns a Singularity Function expression which represents the elastic curve or deflection of the Beam object. Examples ======== There is a beam of length 30 meters. A moment of magnitude 120 Nm is applied in the clockwise direction at the end of the beam. A pointload of magnitude 8 N is applied from the top of the beam at the starting point. There are two simple supports below the beam. One at the end and another one at a distance of 10 meters from the start. The deflection is restricted at both the supports. Using the sign convention of upward forces and clockwise moment being positive. >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> E, I = symbols('E, I') >>> R1, R2 = symbols('R1, R2') >>> b = Beam(30, E, I) >>> b.apply_load(-8, 0, -1) >>> b.apply_load(R1, 10, -1) >>> b.apply_load(R2, 30, -1) >>> b.apply_load(120, 30, -2) >>> b.bc_deflection = [(10, 0), (30, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.deflection() (4000*x/3 - 4*SingularityFunction(x, 0, 3)/3 + SingularityFunction(x, 10, 3) + 60*SingularityFunction(x, 30, 2) + SingularityFunction(x, 30, 3)/3 - 12000)/(E*I) rr1r2r~rrz3:54r)r8r4r7rErr:r5rrrrrrrrrrr9rr2rrrr)rGr/rrrrprev_defrr1rprrecent_segment_slopedeflection_valuerHrconstantrrrrr rrrrIrIrJr1s  ,  8   , " * zBeam.deflectioncsttdjdkfjjkftddf}t|tjtjd} fdd|D}t t t |}t |dkrMt|}||||fSdS)zr Returns point of max deflection and its corresponding deflection value in a Beam object. rrTrcg|] }j|qSrIrr8.0r/rrGrIrJ =z'Beam.max_deflection..N)rrr8r2r3rrrrr1rrrrrr)rGrr deflectionsmax_defrIrrJmax_deflection/s  zBeam.max_deflectioncC||jS)zg Returns an expression representing the Shear Stress curve of the Beam object. rrarUrIrIrJ shear_stressEszBeam.shear_stresscCs||}|j}|j}|duri}|tD]}||kr%||vr%td|q||vr.||}t|||d|fdddddS) a Returns a plot of shear stress present in the beam object. Parameters ========== subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 8 meters and area of cross section 2 square meters. A constant distributed load of 10 KN/m is applied from half of the beam till the end. There are two simple supports below the beam, one at the starting point and another at the ending point of the beam. A pointload of magnitude 5 KN is also applied from top of the beam, at a distance of 4 meters from the starting point. Take E = 200 GPa and I = 400*(10**-6) meter**4. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> R1, R2 = symbols('R1, R2') >>> b = Beam(8, 200*(10**9), 400*(10**-6), 2) >>> b.apply_load(5000, 2, -1) >>> b.apply_load(R1, 0, -1) >>> b.apply_load(R2, 8, -1) >>> b.apply_load(10000, 4, 0, end=8) >>> b.bc_deflection = [(0, 0), (8, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.plot_shear_stress() Plot object containing: [0]: cartesian line: 6875*SingularityFunction(x, 0, 0) - 2500*SingularityFunction(x, 2, 0) - 5000*SingularityFunction(x, 4, 1) + 15625*SingularityFunction(x, 8, 0) + 5000*SingularityFunction(x, 8, 1) for x over (0.0, 8.0) Nzvalue of %s was not passed.rz Shear Stress $\mathrm{x}$z$\tau$rtitlexlabelylabel line_color)rr8r3atomsrrnrr)rGrrr/r3symrIrIrJplot_shear_stressLs- r&cC|}|dur i}|tD]}||jkrq||vr!td|q|j|vr-||j}n|j}t|||jd|fdddddS) a Returns a plot for Shear force present in the Beam object. Parameters ========== subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 8 meters. A constant distributed load of 10 KN/m is applied from half of the beam till the end. There are two simple supports below the beam, one at the starting point and another at the ending point of the beam. A pointload of magnitude 5 KN is also applied from top of the beam, at a distance of 4 meters from the starting point. Take E = 200 GPa and I = 400*(10**-6) meter**4. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> R1, R2 = symbols('R1, R2') >>> b = Beam(8, 200*(10**9), 400*(10**-6)) >>> b.apply_load(5000, 2, -1) >>> b.apply_load(R1, 0, -1) >>> b.apply_load(R2, 8, -1) >>> b.apply_load(10000, 4, 0, end=8) >>> b.bc_deflection = [(0, 0), (8, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.plot_shear_force() Plot object containing: [0]: cartesian line: 13750*SingularityFunction(x, 0, 0) - 5000*SingularityFunction(x, 2, 0) - 10000*SingularityFunction(x, 4, 1) + 31250*SingularityFunction(x, 8, 0) + 10000*SingularityFunction(x, 8, 1) for x over (0.0, 8.0) NValue of %s was not passed.r Shear Forcer $\mathrm{V}$grrr#rr8rnr3rr)rGrrr$r3rIrIrJplot_shear_force+    r%cCr&) a Returns a plot for Bending moment present in the Beam object. Parameters ========== subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 8 meters. A constant distributed load of 10 KN/m is applied from half of the beam till the end. There are two simple supports below the beam, one at the starting point and another at the ending point of the beam. A pointload of magnitude 5 KN is also applied from top of the beam, at a distance of 4 meters from the starting point. Take E = 200 GPa and I = 400*(10**-6) meter**4. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> R1, R2 = symbols('R1, R2') >>> b = Beam(8, 200*(10**9), 400*(10**-6)) >>> b.apply_load(5000, 2, -1) >>> b.apply_load(R1, 0, -1) >>> b.apply_load(R2, 8, -1) >>> b.apply_load(10000, 4, 0, end=8) >>> b.bc_deflection = [(0, 0), (8, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.plot_bending_moment() Plot object containing: [0]: cartesian line: 13750*SingularityFunction(x, 0, 1) - 5000*SingularityFunction(x, 2, 1) - 5000*SingularityFunction(x, 4, 2) + 31250*SingularityFunction(x, 8, 1) + 5000*SingularityFunction(x, 8, 2) for x over (0.0, 8.0) Nr'rBending Momentr $\mathrm{M}$brrr#rr8rnr3rr)rGrrr$r3rIrIrJplot_bending_momentr-r!cCr&) a  Returns a plot for slope of deflection curve of the Beam object. Parameters ========== subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 8 meters. A constant distributed load of 10 KN/m is applied from half of the beam till the end. There are two simple supports below the beam, one at the starting point and another at the ending point of the beam. A pointload of magnitude 5 KN is also applied from top of the beam, at a distance of 4 meters from the starting point. Take E = 200 GPa and I = 400*(10**-6) meter**4. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> R1, R2 = symbols('R1, R2') >>> b = Beam(8, 200*(10**9), 400*(10**-6)) >>> b.apply_load(5000, 2, -1) >>> b.apply_load(R1, 0, -1) >>> b.apply_load(R2, 8, -1) >>> b.apply_load(10000, 4, 0, end=8) >>> b.bc_deflection = [(0, 0), (8, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.plot_slope() Plot object containing: [0]: cartesian line: -8.59375e-5*SingularityFunction(x, 0, 2) + 3.125e-5*SingularityFunction(x, 2, 2) + 2.08333333333333e-5*SingularityFunction(x, 4, 3) - 0.0001953125*SingularityFunction(x, 8, 2) - 2.08333333333333e-5*SingularityFunction(x, 8, 3) + 0.00138541666666667 for x over (0.0, 8.0) Nr'rSloper$\theta$mrr2r#rr8rnr3rr)rGrr2r$r3rIrIrJ plot_sloper-r'cCr&) a0 Returns a plot for deflection curve of the Beam object. Parameters ========== subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 8 meters. A constant distributed load of 10 KN/m is applied from half of the beam till the end. There are two simple supports below the beam, one at the starting point and another at the ending point of the beam. A pointload of magnitude 5 KN is also applied from top of the beam, at a distance of 4 meters from the starting point. Take E = 200 GPa and I = 400*(10**-6) meter**4. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> R1, R2 = symbols('R1, R2') >>> b = Beam(8, 200*(10**9), 400*(10**-6)) >>> b.apply_load(5000, 2, -1) >>> b.apply_load(R1, 0, -1) >>> b.apply_load(R2, 8, -1) >>> b.apply_load(10000, 4, 0, end=8) >>> b.bc_deflection = [(0, 0), (8, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> b.plot_deflection() Plot object containing: [0]: cartesian line: 0.00138541666666667*x - 2.86458333333333e-5*SingularityFunction(x, 0, 3) + 1.04166666666667e-5*SingularityFunction(x, 2, 3) + 5.20833333333333e-6*SingularityFunction(x, 4, 4) - 6.51041666666667e-5*SingularityFunction(x, 8, 3) - 5.20833333333333e-6*SingularityFunction(x, 8, 4) for x over (0.0, 8.0) Nr'r Deflectionr$\delta$rrr1r#rr8rnr3rr)rGrr1r$r3rIrIrJplot_deflection:s ,    r"c Cs|j}|j}|dur i}|tD]}||jkrq||vr%td|q||vr.||}t|||d|fdddddd }t| ||d|fd dd d dd }t| ||d|fd ddddd }t|||d|fdddddd }t dd||||S)a Returns a subplot of Shear Force, Bending Moment, Slope and Deflection of the Beam object. Parameters ========== subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 8 meters. A constant distributed load of 10 KN/m is applied from half of the beam till the end. There are two simple supports below the beam, one at the starting point and another at the ending point of the beam. A pointload of magnitude 5 KN is also applied from top of the beam, at a distance of 4 meters from the starting point. Take E = 200 GPa and I = 400*(10**-6) meter**4. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> R1, R2 = symbols('R1, R2') >>> b = Beam(8, 200*(10**9), 400*(10**-6)) >>> b.apply_load(5000, 2, -1) >>> b.apply_load(R1, 0, -1) >>> b.apply_load(R2, 8, -1) >>> b.apply_load(10000, 4, 0, end=8) >>> b.bc_deflection = [(0, 0), (8, 0)] >>> b.solve_for_reaction_loads(R1, R2) >>> axes = b.plot_loading_results() Nr'rr(rr)r*Frr r!r"showr.r/r0r3r4r5r8r9rrr) r3r8r1r#rrnrrrrr2r) rGrr3r8r$ax1ax2ax3ax4rIrIrJplot_loading_resultsws:)  zBeam.plot_loading_resultscCs&|j}t|j| }t||}||fS)z Helper function for I.L.D. It takes the unsubstituted copy of the load equation and uses it to calculate shear force and bending moment equations. )r8rrD)rGr/rrrIrIrJ_solve_for_ild_equationss zBeam._solve_for_ild_equationscGs|\}}|j}|j}td}td}t||||} t||||||} g} g} t|||} |jdD]\}}| |||}| |q8t| ||}|jdD]\}}||||}| |qVt t | | g| | ||f|j d}|dd}t t |||_dS)a Determines the Influence Line Diagram equations for reaction forces under the effect of a moving load. Parameters ========== value : Integer Magnitude of moving load reactions : The reaction forces applied on the beam. Examples ======== There is a beam of length 10 meters. There are two simple supports below the beam, one at the starting point and another at the ending point of the beam. Calculate the I.L.D. equations for reaction forces under the effect of a moving load of magnitude 1kN. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.physics.continuum_mechanics.beam import Beam >>> E, I = symbols('E, I') >>> R_0, R_10 = symbols('R_0, R_10') >>> b = Beam(10, E, I) >>> p0 = b.apply_support(0, 'roller') >>> p10 = b.apply_support(10, 'roller') >>> b.solve_for_ild_reactions(1,R_0,R_10) >>> b.ild_reactions {R_0: x/10 - 1, R_10: -x/10} rrr2r1rrN)rCr8r3rrrr:rrrrrrrrA)rGrrrrr/r]rrrrrrrrrrrrIrIrJsolve_for_ild_reactionss4 (    zBeam.solve_for_ild_reactionsc Cs|jstd|j}g}|duri}|jD]}|j|tD]}||kr/||vr/td|qq|jtD]}||krG||vrGtd|q7|jD]}|t|j|||d|j|fd||dddqKt t |d g|RS) a> Plots the Influence Line Diagram of Reaction Forces under the effect of a moving load. This function should be called after calling solve_for_ild_reactions(). Parameters ========== subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 10 meters. A point load of magnitude 5KN is also applied from top of the beam, at a distance of 4 meters from the starting point. There are two simple supports below the beam, located at the starting point and at a distance of 7 meters from the starting point. Plot the I.L.D. equations for reactions at both support points under the effect of a moving load of magnitude 1kN. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.physics.continuum_mechanics.beam import Beam >>> E, I = symbols('E, I') >>> R_0, R_7 = symbols('R_0, R_7') >>> b = Beam(10, E, I) >>> p0 = b.apply_support(0, 'roller') >>> p7 = b.apply_support(7, 'roller') >>> b.apply_load(5,4,-1) >>> b.solve_for_ild_reactions(1,R_0,R_7) >>> b.ild_reactions {R_0: x/7 - 22/7, R_7: -x/7 - 20/7} >>> b.plot_ild_reactions() PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: x/7 - 22/7 for x over (0.0, 10.0) Plot[1]:Plot object containing: [0]: cartesian line: -x/7 - 20/7 for x over (0.0, 10.0) ztI.L.D. reaction equations not found. Please use solve_for_ild_reactions() to generate the I.L.D. reaction equations.Nr'rzI.L.D. for ReactionsblueFr<r) rArnr8r#rrOrrrrr)rGrr/ildplotsreactionr$rIrIrJplot_ild_reactions s,3     zBeam.plot_ild_reactionsc Gs|j}|j}|\}}|t|||}t|||t||||} |D]} || |j| }| | |j| } q$t|||kf| ||kf} | |_dS)a Determines the Influence Line Diagram equations for shear at a specified point under the effect of a moving load. Parameters ========== distance : Integer Distance of the point from the start of the beam for which equations are to be determined value : Integer Magnitude of moving load reactions : The reaction forces applied on the beam. Examples ======== There is a beam of length 12 meters. There are two simple supports below the beam, one at the starting point and another at a distance of 8 meters. Calculate the I.L.D. equations for Shear at a distance of 4 meters under the effect of a moving load of magnitude 1kN. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.physics.continuum_mechanics.beam import Beam >>> E, I = symbols('E, I') >>> R_0, R_8 = symbols('R_0, R_8') >>> b = Beam(12, E, I) >>> p0 = b.apply_support(0, 'roller') >>> p8 = b.apply_support(8, 'roller') >>> b.solve_for_ild_reactions(1, R_0, R_8) >>> b.solve_for_ild_shear(4, 1, R_0, R_8) >>> b.ild_shear Piecewise((x/8, x < 4), (x/8 - 1, x > 4)) N)r8r3rCrrrArrB) rGdistancerrr/r]r_ shear_curve1 shear_curve2rGshear_eqrIrIrJsolve_for_ild_shearYs-  zBeam.solve_for_ild_shearc Cs|jstd|j}|j}|duri}|jtD]}||kr)||vr)td|q|jtD]}||kr@||vr@td|q0t|j||d|fddddd d S) a Plots the Influence Line Diagram for Shear under the effect of a moving load. This function should be called after calling solve_for_ild_shear(). Parameters ========== subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 12 meters. There are two simple supports below the beam, one at the starting point and another at a distance of 8 meters. Plot the I.L.D. for Shear at a distance of 4 meters under the effect of a moving load of magnitude 1kN. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.physics.continuum_mechanics.beam import Beam >>> E, I = symbols('E, I') >>> R_0, R_8 = symbols('R_0, R_8') >>> b = Beam(12, E, I) >>> p0 = b.apply_support(0, 'roller') >>> p8 = b.apply_support(8, 'roller') >>> b.solve_for_ild_reactions(1, R_0, R_8) >>> b.solve_for_ild_shear(4, 1, R_0, R_8) >>> b.ild_shear Piecewise((x/8, x < 4), (x/8 - 1, x > 4)) >>> b.plot_ild_shear() Plot object containing: [0]: cartesian line: Piecewise((x/8, x < 4), (x/8 - 1, x > 4)) for x over (0.0, 12.0) ziI.L.D. shear equation not found. Please use solve_for_ild_shear() to generate the I.L.D. shear equations.Nr'rzI.L.D. for Shear $\mathrm{X}$r)rETr<)rBrnr8rOr#rrr)rGrr/r]r$rIrIrJplot_ild_shears".  r$c Gs|j}|j}|\}}|||t|||}t|||t||||||} |D]} || |j| }| | |j| } q,t|||kf| ||kf} | |_dS)a Determines the Influence Line Diagram equations for moment at a specified point under the effect of a moving load. Parameters ========== distance : Integer Distance of the point from the start of the beam for which equations are to be determined value : Integer Magnitude of moving load reactions : The reaction forces applied on the beam. Examples ======== There is a beam of length 12 meters. There are two simple supports below the beam, one at the starting point and another at a distance of 8 meters. Calculate the I.L.D. equations for Moment at a distance of 4 meters under the effect of a moving load of magnitude 1kN. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.physics.continuum_mechanics.beam import Beam >>> E, I = symbols('E, I') >>> R_0, R_8 = symbols('R_0, R_8') >>> b = Beam(12, E, I) >>> p0 = b.apply_support(0, 'roller') >>> p8 = b.apply_support(8, 'roller') >>> b.solve_for_ild_reactions(1, R_0, R_8) >>> b.solve_for_ild_moment(4, 1, R_0, R_8) >>> b.ild_moment Piecewise((-x/2, x < 4), (x/2 - 4, x > 4)) N)r8r3rCrrrArrC) rGrIrrr/r]rJmoment moment_curve1 moment_curve2rG moment_eqrIrIrJsolve_for_ild_moments- $ zBeam.solve_for_ild_momentc Cs|jstd|j}|duri}|jtD]}||kr&||vr&td|q|jtD]}||kr=||vr=td|q-t|j||d|jfddddd d S) a Plots the Influence Line Diagram for Moment under the effect of a moving load. This function should be called after calling solve_for_ild_moment(). Parameters ========== subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 12 meters. There are two simple supports below the beam, one at the starting point and another at a distance of 8 meters. Plot the I.L.D. for Moment at a distance of 4 meters under the effect of a moving load of magnitude 1kN. Using the sign convention of downwards forces being positive. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.physics.continuum_mechanics.beam import Beam >>> E, I = symbols('E, I') >>> R_0, R_8 = symbols('R_0, R_8') >>> b = Beam(12, E, I) >>> p0 = b.apply_support(0, 'roller') >>> p8 = b.apply_support(8, 'roller') >>> b.solve_for_ild_reactions(1, R_0, R_8) >>> b.solve_for_ild_moment(4, 1, R_0, R_8) >>> b.ild_moment Piecewise((-x/2, x < 4), (x/2 - 4, x > 4)) >>> b.plot_ild_moment() Plot object containing: [0]: cartesian line: Piecewise((-x/2, x < 4), (x/2 - 4, x > 4)) for x over (0.0, 12.0) zlI.L.D. moment equation not found. Please use solve_for_ild_moment() to generate the I.L.D. moment equations.Nr'rzI.L.D. for MomentrOr/rETr<)rCrnr8r#rrOrr)rGrr/r$rIrIrJplot_ild_moments .  r#)r))modulesTcCststdtt|jt|j}|s!tdd|Dr!td|j}t |j t r?t|j t }t|d}|j |}ni}|j }|d}g}|d||dd||||\}} } } } |||\} }||7}| | 7} |jd kr|j|j }t||}| |g|d ggd d d dg7} | d|f}| rtt| dtdd|D}tt| dtdd|D}||dks||dkrt||d}||||f}t|| || |d|f| ||f||| |d| ddd }|S)a$ Returns a plot object representing the beam diagram of the beam. In particular, the diagram might include: * the beam. * vertical black arrows represent point loads and support reaction forces (the latter if they have been added with the ``apply_load`` method). * circular arrows represent moments. * shaded areas represent distributed loads. * the support, if ``apply_support`` has been executed. * if a composite beam has been created with the ``join`` method and a hinge has been specified, it will be shown with a white disc. The diagram shows positive loads on the upper side of the beam, and negative loads on the lower side. If two or more distributed loads acts along the same direction over the same region, the function will add them up together. .. note:: The user must be careful while entering load values. The draw function assumes a sign convention which is used for plotting loads. Given a right handed coordinate system with XYZ coordinates, the beam's length is assumed to be along the positive X axis. The draw function recognizes positive loads(with n>-2) as loads acting along negative Y direction and positive moments acting along positive Z direction. Parameters ========== pictorial: Boolean (default=True) Setting ``pictorial=True`` would simply create a pictorial (scaled) view of the beam diagram. On the other hand, ``pictorial=False`` would create a beam diagram with the exact dimensions on the plot. Examples ======== .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam >>> from sympy import symbols >>> P1, P2, M = symbols('P1, P2, M') >>> E, I = symbols('E, I') >>> b = Beam(50, 20, 30) >>> b.apply_load(-10, 2, -1) >>> b.apply_load(15, 26, -1) >>> b.apply_load(P1, 10, -1) >>> b.apply_load(-P2, 40, -1) >>> b.apply_load(90, 5, 0, 23) >>> b.apply_load(10, 30, 1, 50) >>> b.apply_load(M, 15, -2) >>> b.apply_load(-M, 30, -2) >>> p50 = b.apply_support(50, "pin") >>> p0, m0 = b.apply_support(0, "fixed") >>> p20 = b.apply_support(20, "roller") >>> p = b.draw() # doctest: +SKIP >>> p # doctest: +ELLIPSIS,+SKIP Plot object containing: [0]: cartesian line: 25*SingularityFunction(x, 5, 0) - 25*SingularityFunction(x, 23, 0) + SingularityFunction(x, 30, 1) - 20*SingularityFunction(x, 50, 0) - SingularityFunction(x, 50, 1) + 5 for x over (0.0, 50.0) [1]: cartesian line: 5 for x over (0.0, 50.0) ... >>> p.show() # doctest: +SKIP z-To use this function numpy module is requiredcss.|]}t|djdko|ddkVqdS)rrN)r free_symbols)rr]rIrIrJ s,zBeam.draw..zl`pictorial=False` requires numerical distributed loads. Instead, symbolic loads were found. Cannot continue. rrbrown)xywidthheight facecolorrrowhitermarker markersizecolorg?y2cs|] }|ddVqdSr]rNrIrrrIrIrJrYy1csrirjrIrkrIrIrJrYrlrrg?F) xlimylim annotationsmarkers rectanglesr"fillaxisr=)r) ImportErrorrrrr>anyrnr8r5r3rr#rrfromkeysrr _draw_load_draw_supportsrErFrminrrr)rG pictorialloadsr/r]r3r_rrrprqload_eqload_eq1rssupport_markerssupport_rectanglesratiox_posro_min_maxoffset sing_plotrIrIrJdrawTsHJ        r cCs&|j}|js |dur |S|jS)zTry to determine if a load is negative or positive, using expansion and doit if necessary. Returns ======= True: if the load is negative False: if the load is positive None: if it is indeterminate N)ris_Atomdoitexpand)rGrrvrIrIrJ_is_load_negatives zBeam._is_load_negativec sbtt|jt|j}|d}|j}g}g}g} d} g} d} tj} tj}d}d}d}|D]}r:|d}n|d}|ddkr||d}|dur[|d|d|df7}|ru| d|df||d |fd d d d d dq-| d||f||d fd d d d d dq-|ddkr||d}|dur|d|d|df7}||dr| |g|dggdddq-| |g|dggdddq-|ddkr|\}}}}||}|dur|d|||f7}|s^|r|dkrdd|n|d}| |t |||7} |rE|dkr|||n|d||}t d|dD]}| | |||||t |||t |8} q)t| trO| j} n| f} tfdd| D} q-|rp|dkrldd|n|d}| t|t |||7} |r|dkrt|||n|d||}t d|dD]}| | |||||t |||t |8} qt| tr| j} n| f} fdd| D}t| |}q-t|dkrt||tdt|d}t|g|| t|}t|g||t|}t|tjs|t|9}t|tjs"|t|9}|||ddd}||| ||fS)NrZrzPlease, note that this schematic view might not be in agreement with the sign convention used by the Beam class for load-related computations, because it was not possible to determine the sign (hence, the direction) of the following loads: rrrz* Point load %s located at %s rg?rblack)r^ headlength headwidthr`)textr]xytext arrowpropsrz* Moment %s located at %s z$\circlearrowright$)rrerfz$\circlearrowleft$z$* Distributed load %s from %s to %s cg|]}|qSrIrrrpr]rIrJr6 z#Beam._draw_load..crrIrrrrIrJrJ rgMbP? darkkhaki)r/rmrhrgzorder)rrrr>r8rZerorrrrrrrr5rrrrwarningswarnr)r+rrrrndarray ones_like)rGr{r3r]r|r_r/rprq load_args scaled_load load_args1 scaled_load1r}r~rs warning_head warning_bodyrposilnrrrrf2rpxxyy1yy2rIrrJrxs  0,     &  *  zBeam._draw_loadc Cst|d}g}g}|jD]q}|r|d|}n|d}|ddkr1||dggddddq |dd krH||| d ggd d ddq |dd kr~|dkri|dd|f| dd||dddq ||d|f|dd||dddq ||fS)NrZrrrrb rrdrg@ra r~Fz/////)r]r^r_rshatch)rr=rr)rGr3r]r_rrsupportrrIrIrJry\ s"    " .*zBeam._draw_supportsr~r\)T):__name__ __module__ __qualname____doc__rrKrSpropertyrVrXrYrZr3setterr<r8r4r7r6rtrwr|rrrrrrrrrrrrrrr2r1rrr%r,r2r7r;rBrCrDrHrNrPrUrVrrrrxryrIrIrIrJr--s]@                       ? I D@  C"2"6)D  @ : : : =C EL =B <@  wr-cseZdZdZedffdd ZeddZejddZedd Z e jd d Z ed d Z e jd d Z eddZ eddZ eddZ ddZdZddZdZddZd[ddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd\d7d8Zd]d:d;Zd\dd?Z!d\d@dAZ"d]dBdCZ#d\dDdEZ$d]dFdGZ%d^dHdIZ&d\dJdKZ'd]dLdMZ(dNdOZ)dPdQZ*dRdSZ+dTdUZ,e,Z-dVdWZ.dXdYZ/Z0S)_Beam3Da! This class handles loads applied in any direction of a 3D space along with unequal values of Second moment along different axes. .. note:: A consistent sign convention must be used while solving a beam bending problem; the results will automatically follow the chosen sign convention. This class assumes that any kind of distributed load/moment is applied through out the span of a beam. Examples ======== There is a beam of l meters long. A constant distributed load of magnitude q is applied along y-axis from start till the end of beam. A constant distributed moment of magnitude m is also applied along z-axis from start till the end of beam. Beam is fixed at both of its end. So, deflection of the beam at the both ends is restricted. >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols, simplify, collect, factor >>> l, E, G, I, A = symbols('l, E, G, I, A') >>> b = Beam3D(l, E, G, I, A) >>> x, q, m = symbols('x, q, m') >>> b.apply_load(q, 0, 0, dir="y") >>> b.apply_moment_load(m, 0, -1, dir="z") >>> b.shear_force() [0, -q*x, 0] >>> b.bending_moment() [0, 0, -m*x + q*x**2/2] >>> b.bc_slope = [(0, [0, 0, 0]), (l, [0, 0, 0])] >>> b.bc_deflection = [(0, [0, 0, 0]), (l, [0, 0, 0])] >>> b.solve_slope_deflection() >>> factor(b.slope()) [0, 0, x*(-l + x)*(-A*G*l**3*q + 2*A*G*l**2*q*x - 12*E*I*l*q - 72*E*I*m + 24*E*I*q*x)/(12*E*I*(A*G*l**2 + 12*E*I))] >>> dx, dy, dz = b.deflection() >>> dy = collect(simplify(dy), x) >>> dx == dz == 0 True >>> dy == (x*(12*E*I*l*(A*G*l**2*q - 2*A*G*l*m + 12*E*I*q) ... + x*(A*G*l*(3*l*(A*G*l**2*q - 2*A*G*l*m + 12*E*I*q) + x*(-2*A*G*l**2*q + 4*A*G*l*m - 24*E*I*q)) ... + A*G*(A*G*l**2 + 12*E*I)*(-2*l**2*q + 6*l*m - 4*m*x + q*x**2) ... - 12*E*I*q*(A*G*l**2 + 12*E*I)))/(24*A*E*G*I*(A*G*l**2 + 12*E*I))) True References ========== .. [1] https://homes.civil.aau.dk/jc/FemteSemester/Beams3D.pdf r/cs`t||||||_||_gd|_gd|_i|_gd|_gd|_gd|_ d|_ dS)aInitializes the class. Parameters ========== length : Sympifyable A Symbol or value representing the Beam's length. elastic_modulus : Sympifyable A SymPy expression representing the Beam's Modulus of Elasticity. It is a measure of the stiffness of the Beam material. shear_modulus : Sympifyable A SymPy expression representing the Beam's Modulus of rigidity. It is a measure of rigidity of the Beam material. second_moment : Sympifyable or list A list of two elements having SymPy expression representing the Beam's Second moment of area. First value represent Second moment across y-axis and second across z-axis. Single SymPy expression can be passed if both values are same area : Sympifyable A SymPy expression representing the Beam's cross-sectional area in a plane perpendicular to length of the Beam. variable : Symbol, optional A Symbol object that will be used as the variable along the beam while representing the load, shear, moment, slope and deflection curve. By default, it is set to ``Symbol('x')``. rrrrN) superrK shear_modulusr< _load_vector_moment_load_vector_torsion_moment_load_Singularity_slope _deflection_angular_deflection)rGr3r4rr7r<r8 __class__rIrJrK s      zBeam3D.__init__cCrTri)_shear_modulusrUrIrIrJr rWzBeam3D.shear_moduluscCr[r\)r rrjrIrIrJr r^cCrTrlrmrUrIrIrJr7 rWzBeam3D.second_momentcCs0t|trdd|D}||_dSt||_dS)NcSsg|]}t|qSrIr rrIrIrJr sz(Beam3D.second_moment..)r5rrMr rorIrIrJr7 s  cCrTr_r`rUrIrIrJr< rWz Beam3D.areacCr[r\rbrcrIrIrJr< r^cCrT)zL Returns a three element list representing the load vector. )rrUrIrIrJ load_vector zBeam3D.load_vectorcCrT)zQ Returns a three element list representing moment loads on Beam. )rrUrIrIrJmoment_load_vector rzBeam3D.moment_load_vectorcCrT)a  Returns a dictionary of boundary conditions applied on the beam. The dictionary has two keywords namely slope and deflection. The value of each keyword is a list of tuple, where each tuple contains location and value of a boundary condition in the format (location, value). Further each value is a list corresponding to slope or deflection(s) values along three axes at that location. Examples ======== There is a beam of length 4 meters. The slope at 0 should be 4 along the x-axis and 0 along others. At the other end of beam, deflection along all the three axes should be zero. >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(30, E, G, I, A, x) >>> b.bc_slope = [(0, (4, 0, 0))] >>> b.bc_deflection = [(4, [0, 0, 0])] >>> b.boundary_conditions {'deflection': [(4, [0, 0, 0])], 'slope': [(0, (4, 0, 0))]} Here the deflection of the beam should be ``0`` along all the three axes at ``4``. Similarly, the slope of the beam should be ``4`` along x-axis and ``0`` along y and z axis at ``0``. rsrUrIrIrJrt szBeam3D.boundary_conditionscCst|js d|jSt|jS)a Returns the polar moment of area of the beam about the X axis with respect to the centroid. Examples ======== >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A = symbols('l, E, G, I, A') >>> b = Beam3D(l, E, G, I, A) >>> b.polar_moment() 2*I >>> I1 = [9, 15] >>> b = Beam3D(l, E, G, I1, A) >>> b.polar_moment() 24 r)rr7sumrUrIrIrJ polar_moment s   zBeam3D.polar_momentycCs|j}t|}t|}t|}|dkr1|dks |jd|7<|jd|t|||7<dS|dkrS|dksB|jd|7<|jd|t|||7<dS|dks`|jd|7<|jd|t|||7<dS)a This method adds up the force load to a particular beam object. Parameters ========== value : Sympifyable The magnitude of an applied load. dir : String Axis along which load is applied. order : Integer The order of the applied load. - For point loads, order=-1 - For constant distributed load, order=0 - For ramp loads, order=1 - For parabolic ramp loads, order=2 - ... so on. r/rrrrrN)r8r rrrrGrrrdirr/rIrIrJr5 s"""zBeam3D.apply_loadcCs|j}t|}t|}t|}|dkrH|dks!|jd|7<n|t|jvr2|j||7<n||j|<|jd|t|||7<dS|dkrj|dksY|jd|7<|jd|t|||7<dS|dksw|jd|7<|jd|t|||7<dS)a# This method adds up the moment loads to a particular beam object. Parameters ========== value : Sympifyable The magnitude of an applied moment. dir : String Axis along which moment is applied. order : Integer The order of the applied load. - For point moments, order=-2 - For constant distributed moment, order=-1 - For ramp moments, order=0 - For parabolic ramp moments, order=1 - ... so on. r/rrrrrN)r8r rrrrrrrIrIrJapply_moment_load[ s$ """zBeam3D.apply_moment_loadr~cCs|dvrtdt|}||j|<|j|gdfdStdt|}tdt|}||g|j|<|j|gdf|j|gdfdS)Nrrrr)rrr@r|rrwrrIrIrJr s zBeam3D.apply_supportc s|j|j}|j}fdd|DfddDtdD]Wfdd|D}t|dkr3qt|}t|}tt||g|jd}t t ||}|j } |D]} | | vro|| | | krot d| q[|j |qdS) a Solves for the reaction forces. Examples ======== There is a beam of length 30 meters. It it supported by rollers at of its end. A constant distributed load of magnitude 8 N is applied from start till its end along y-axis. Another linear load having slope equal to 9 is applied along z-axis. >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(30, E, G, I, A, x) >>> b.apply_load(8, start=0, order=0, dir="y") >>> b.apply_load(9*x, start=0, order=0, dir="z") >>> b.bc_deflection = [(0, [0, 0, 0]), (30, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="y") >>> b.apply_load(R2, start=30, order=-1, dir="y") >>> b.apply_load(R3, start=0, order=-1, dir="z") >>> b.apply_load(R4, start=30, order=-1, dir="z") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.reaction_loads {R1: -120, R2: -120, R3: -1350, R4: -2700} cg|]}t|qSrIr)rrr/rIrJr rz3Beam3D.solve_for_reaction_loads..crrIr)rshearrrIrJr rrcs,g|]}|s|r|qSrI)hasrk)rp moment_curves shear_curvesrIrJr s,rz2Ambiguous solution for %s in different directions.N)r8r3rrrrrrrrrr@rnupdate) rGrGr]qreactrrsolsol_dictrVkeyrI)rprrr/rJr s(   zBeam3D.solve_for_reaction_loadscCs:|j}|j}t|d |t|d |t|d |gS)z Returns a list of three expressions which represents the shear force curve of the Beam object along all three axes. rrr)r8rr)rGr/rrIrIrJr s.zBeam3D.shear_forcecC |dS)zY Returns expression of Axial shear force present inside the Beam object. r)rrUrIrIrJ axial_force  zBeam3D.axial_forcecCs4|d|j|d|j|d|jgS)z Returns a list of three expressions which represents the shear stress curve of the Beam object along all three axes. rrrrrUrIrIrJr s4zBeam3D.shear_stresscCr)zT Returns expression of Axial stress present inside the Beam object. )rrarUrIrIrJ axial_stress szBeam3D.axial_stresscCsR|j}|j}|}t|d |t|d |d|t|d |d|gS)z Returns a list of three expressions which represents the bending moment curve of the Beam object along all three axes. rrr)r8rrr)rGr/r5rrIrIrJr s $zBeam3D.bending_momentcCr)zX Returns expression of Torsional moment present inside the Beam object. r)rrUrIrIrJtorsional_moment rzBeam3D.torsional_momentc Cs|j}d}t|jD] }||j|7}q t|jt|j}t|||dkfd||dkf}tt|ddD])}||j||d8}|td|||dkf||||kfd|||kf7}q;t|}||j| |_ dS)af Solves for the angular deflection due to the torsional effects of moments being applied in the x-direction i.e. out of or into the beam. Here, a positive torque means the direction of the torque is positive i.e. out of the beam along the beam-axis. Likewise, a negative torque signifies a torque into the beam cross-section. Examples ======== >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, E, G, I, A, x) >>> b.apply_moment_load(4, 4, -2, dir='x') >>> b.apply_moment_load(4, 8, -2, dir='x') >>> b.apply_moment_load(4, 8, -2, dir='x') >>> b.solve_for_torsion() >>> b.angular_deflection().subs(x, 3) 18/(G*I) rrN) r8rrrrrrrrrr)rGr/ sum_momentsr pointsListtorque_diagramrpintegrated_torque_diagramrIrIrJsolve_for_torsion s ":zBeam3D.solve_for_torsioncCs|j}|j}|j}|j}|j}t|tr|d|d}}n|}}|j}|j} |j } t d} t d} t ||t | |||| d} t t | d| |jd}td}td}tt||d|||g||jd}|||d||di}||}||jd<||jd<td}t ||t | |||t| d ||| d}t t |djd}tt||d|||g||jd}|||d||di}||t | ||| d|||||}t t |d| |jd}tt||d|||g||jd}|||d||di|jd<|||d|jd<t ||t | |||t| d||| d}t t |djd}tt||d|||g||jd}|||d||di}||t | ||| d|||||}t t |djd}tt||d|||g||jd}|||d||di|jd<|||d|jd<dS) NrrdeflthetarrC_ir)r8r3r4rr7r5rrarrr rrr rrrrrrrr)rGr/r]rGrI_yI_zr.rrQrrrdef_xrrrslope_xreq1slope_zeq2def_yslope_ydef_zrIrIrJsolve_slope_deflection sR $*   8*2* 6*2* zBeam3D.solve_slope_deflectioncCrT)zw Returns a three element list representing slope of deflection curve along all the three axes. )rrUrIrIrJr2V rz Beam3D.slopecCrT)zn Returns a three element list representing deflection curve along all the three axes. )rrUrIrIrJr1] rzBeam3D.deflectioncCrT)z Returns a function in x depicting how the angular deflection, due to moments in the x-axis on the beam, varies with x. )rrUrIrIrJangular_deflectiond rzBeam3D.angular_deflectionNc C|}|dkr d}d}n|dkrd}d}n|dkrd}d }|dur$i}||tD]}||jkr<||vr>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, E, G, I, A, x) >>> b.apply_load(15, start=0, order=0, dir="z") >>> b.apply_load(12*x, start=0, order=0, dir="y") >>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="z") >>> b.apply_load(R2, start=20, order=-1, dir="z") >>> b.apply_load(R3, start=0, order=-1, dir="y") >>> b.apply_load(R4, start=20, order=-1, dir="y") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.plot_shear_force() PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: 0 for x over (0.0, 20.0) Plot[1]:Plot object containing: [0]: cartesian line: -6*x**2 for x over (0.0, 20.0) Plot[2]:Plot object containing: [0]: cartesian line: -15*x for x over (0.0, 20.0) r/rrrr)lowerrr=rrGrrPxPyPzrIrIrJr, 4      zBeam3D.plot_shear_forcec Cr)Nr/rr*rrcrrr5r'Fz!Bending Moment along %c directionrOz$\mathrm{M(%c)}$rr1)rGrrrrrgr$r3rIrIrJ_plot_bending_moment rzBeam3D._plot_bending_momentcCr)a  Returns a plot for bending moment along all three directions present in the Beam object. Parameters ========== dir : string (default : "all") Direction along which bending moment plot is required. If no direction is specified, all plots are displayed. subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 20 meters. It is supported by rollers at both of its ends. A linear load having slope equal to 12 is applied along y-axis. A constant distributed load of magnitude 15 N is applied from start till its end along z-axis. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, E, G, I, A, x) >>> b.apply_load(15, start=0, order=0, dir="z") >>> b.apply_load(12*x, start=0, order=0, dir="y") >>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="z") >>> b.apply_load(R2, start=20, order=-1, dir="z") >>> b.apply_load(R3, start=0, order=-1, dir="y") >>> b.apply_load(R4, start=20, order=-1, dir="y") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.plot_bending_moment() PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: 0 for x over (0.0, 20.0) Plot[1]:Plot object containing: [0]: cartesian line: -15*x**2/2 for x over (0.0, 20.0) Plot[2]:Plot object containing: [0]: cartesian line: 2*x**3 for x over (0.0, 20.0) r/rrrr)rrr=rrrIrIrJr2 rzBeam3D.plot_bending_momentc Cr)Nr/rr0rrr5rrr*r'FzSlope along %c directionrOz$\mathrm{\theta(%c)}$rr6)rGrrr2rrgr$r3rIrIrJ _plot_slope7 s,     zBeam3D._plot_slopecCr)aP Returns a plot for Slope along all three directions present in the Beam object. Parameters ========== dir : string (default : "all") Direction along which Slope plot is required. If no direction is specified, all plots are displayed. subs : dictionary Python dictionary containing Symbols as keys and their corresponding values. Examples ======== There is a beam of length 20 meters. It is supported by rollers at both of its ends. A linear load having slope equal to 12 is applied along y-axis. A constant distributed load of magnitude 15 N is applied from start till its end along z-axis. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, 40, 21, 100, 25, x) >>> b.apply_load(15, start=0, order=0, dir="z") >>> b.apply_load(12*x, start=0, order=0, dir="y") >>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="z") >>> b.apply_load(R2, start=20, order=-1, dir="z") >>> b.apply_load(R3, start=0, order=-1, dir="y") >>> b.apply_load(R4, start=20, order=-1, dir="y") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.solve_slope_deflection() >>> b.plot_slope() PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: 0 for x over (0.0, 20.0) Plot[1]:Plot object containing: [0]: cartesian line: -x**3/1600 + 3*x**2/160 - x/8 for x over (0.0, 20.0) Plot[2]:Plot object containing: [0]: cartesian line: x**4/8000 - 19*x**2/172 + 52*x/43 for x over (0.0, 20.0) r/rrrr)rrr=rrrIrIrJr7V s5      zBeam3D.plot_slopec Cr)Nr/rr5rrrrrrr'FzDeflection along %c directionrOz$\mathrm{\delta(%c)}$rr:)rGrrr1rrgr$r3rIrIrJ_plot_deflection rzBeam3D._plot_deflectioncCr)a Returns a plot for Deflection along all three directions present in the Beam object. Parameters ========== dir : string (default : "all") Direction along which deflection plot is required. If no direction is specified, all plots are displayed. subs : dictionary Python dictionary containing Symbols as keys and their corresponding values. Examples ======== There is a beam of length 20 meters. It is supported by rollers at both of its ends. A linear load having slope equal to 12 is applied along y-axis. A constant distributed load of magnitude 15 N is applied from start till its end along z-axis. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, 40, 21, 100, 25, x) >>> b.apply_load(15, start=0, order=0, dir="z") >>> b.apply_load(12*x, start=0, order=0, dir="y") >>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="z") >>> b.apply_load(R2, start=20, order=-1, dir="z") >>> b.apply_load(R3, start=0, order=-1, dir="y") >>> b.apply_load(R4, start=20, order=-1, dir="y") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.solve_slope_deflection() >>> b.plot_deflection() PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: 0 for x over (0.0, 20.0) Plot[1]:Plot object containing: [0]: cartesian line: x**5/40000 - 4013*x**3/90300 + 26*x**2/43 + 1520*x/903 for x over (0.0, 20.0) Plot[2]:Plot object containing: [0]: cartesian line: x**4/6400 - x**3/160 + 27*x**2/560 + 2*x/7 for x over (0.0, 20.0) r/rrrr)rrr=rrrIrIrJr; s6      zBeam3D.plot_deflectioncCsV|}|dur i}|||}|||}|||}|||}tdd||||S)aP Returns a subplot of Shear Force, Bending Moment, Slope and Deflection of the Beam object along the direction specified. Parameters ========== dir : string (default : "x") Direction along which plots are required. If no direction is specified, plots along x-axis are displayed. subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 20 meters. It is supported by rollers at both of its ends. A linear load having slope equal to 12 is applied along y-axis. A constant distributed load of magnitude 15 N is applied from start till its end along z-axis. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, E, G, I, A, x) >>> subs = {E:40, G:21, I:100, A:25} >>> b.apply_load(15, start=0, order=0, dir="z") >>> b.apply_load(12*x, start=0, order=0, dir="y") >>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="z") >>> b.apply_load(R2, start=20, order=-1, dir="z") >>> b.apply_load(R3, start=0, order=-1, dir="y") >>> b.apply_load(R4, start=20, order=-1, dir="y") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.solve_slope_deflection() >>> b.plot_loading_results('y',subs) PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: -6*x**2 for x over (0.0, 20.0) Plot[1]:Plot object containing: [0]: cartesian line: -15*x**2/2 for x over (0.0, 20.0) Plot[2]:Plot object containing: [0]: cartesian line: -x**3/1600 + 3*x**2/160 - x/8 for x over (0.0, 20.0) Plot[3]:Plot object containing: [0]: cartesian line: x**5/40000 - 4013*x**3/90300 + 26*x**2/43 + 1520*x/903 for x over (0.0, 20.0) Nrr)rrrrrr)rGrrr>r?r@rArIrIrJrB s9    zBeam3D.plot_loading_resultsc Cr)Nr/rrrrr*rrr0r'FzShear stress along %c directionrOz $\tau(%c)$r)rr#rr8rnr3rr)rGrrrrrgr$r3rIrIrJ_plot_shear_stressK rzBeam3D._plot_shear_stresscCr)a. Returns a plot for Shear Stress along all three directions present in the Beam object. Parameters ========== dir : string (default : "all") Direction along which shear stress plot is required. If no direction is specified, all plots are displayed. subs : dictionary Python dictionary containing Symbols as key and their corresponding values. Examples ======== There is a beam of length 20 meters and area of cross section 2 square meters. It is supported by rollers at both of its ends. A linear load having slope equal to 12 is applied along y-axis. A constant distributed load of magnitude 15 N is applied from start till its end along z-axis. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, E, G, I, 2, x) >>> b.apply_load(15, start=0, order=0, dir="z") >>> b.apply_load(12*x, start=0, order=0, dir="y") >>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="z") >>> b.apply_load(R2, start=20, order=-1, dir="z") >>> b.apply_load(R3, start=0, order=-1, dir="y") >>> b.apply_load(R4, start=20, order=-1, dir="y") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.plot_shear_stress() PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: 0 for x over (0.0, 20.0) Plot[1]:Plot object containing: [0]: cartesian line: -3*x**2 for x over (0.0, 20.0) Plot[2]:Plot object containing: [0]: cartesian line: -15*x/2 for x over (0.0, 20.0) r/rrrr)rr r=rrrIrIrJr%i rzBeam3D.plot_shear_stresscs|}|dkr d}n |dkrd}n|dkrd}|s dSttdjdkfj|jjkftdd f}t|tjt j d }| d| j|fd d |D}t t t|}t|}||||fS) z8 Helper function for max_shear_force(). r/rrrrrr[rTrcsg|] }j|qSrIrrrGrrIrJr rz+Beam3D._max_shear_force..)rrrrr8rr3rrrrrrrrrr)rGrr load_curverrrrIr rJ_max_shear_force s.     zBeam3D._max_shear_forcecC8g}||d||d||d|S)a Returns point of max shear force and its corresponding shear value along all directions in a Beam object as a list. solve_for_reaction_loads() must be called before using this function. Examples ======== There is a beam of length 20 meters. It is supported by rollers at both of its ends. A linear load having slope equal to 12 is applied along y-axis. A constant distributed load of magnitude 15 N is applied from start till its end along z-axis. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, 40, 21, 100, 25, x) >>> b.apply_load(15, start=0, order=0, dir="z") >>> b.apply_load(12*x, start=0, order=0, dir="y") >>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="z") >>> b.apply_load(R2, start=20, order=-1, dir="z") >>> b.apply_load(R3, start=0, order=-1, dir="y") >>> b.apply_load(R4, start=20, order=-1, dir="y") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.max_shear_force() [(0, 0), (20, 2400), (20, 300)] r/rr)rr )rGrrIrIrJr #zBeam3D.max_shear_forcecs|}|dkr d}n |dkrd}n|dkrd}|s dSttdjdkf|jjkftdd f}t|tjt j d }| d| j|fd d |D}t t t|}t|}||||fS) z; Helper function for max_bending_moment(). r/rrrrrr[rTrcrrIrrbending_moment_curverGrIrJrrz.Beam3D._max_bending_moment..)rrrrr8rr3rrrrrrrrrr)rGrrrrbending_momentsmax_bending_momentrIrrJ_max_bending_moment .     zBeam3D._max_bending_momentcCr )a Returns point of max bending moment and its corresponding bending moment value along all directions in a Beam object as a list. solve_for_reaction_loads() must be called before using this function. Examples ======== There is a beam of length 20 meters. It is supported by rollers at both of its ends. A linear load having slope equal to 12 is applied along y-axis. A constant distributed load of magnitude 15 N is applied from start till its end along z-axis. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, 40, 21, 100, 25, x) >>> b.apply_load(15, start=0, order=0, dir="z") >>> b.apply_load(12*x, start=0, order=0, dir="y") >>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="z") >>> b.apply_load(R2, start=20, order=-1, dir="z") >>> b.apply_load(R3, start=0, order=-1, dir="y") >>> b.apply_load(R4, start=20, order=-1, dir="y") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.max_bending_moment() [(0, 0), (20, 3000), (20, 16000)] r/rr)rr)rGrrIrIrJrrzBeam3D.max_bending_momentcs|}|dkr d}n |dkrd}n|dkrd}|s dSttdjdkf|jjkftdd f}t|tjt j d }| d| j |fd d |D}t tt|}t|}||||fS) z6 Helper function for max_Deflection() r/rrrrrr[rTrcrrIrrrrIrJrerz*Beam3D._max_deflection..)rr1rrr8r2r3rrrrrrOrrrrr)rGrrrrrrrIrrJ_max_deflectionIrzBeam3D._max_deflectioncCr )a Returns point of max deflection and its corresponding deflection value along all directions in a Beam object as a list. solve_for_reaction_loads() and solve_slope_deflection() must be called before using this function. Examples ======== There is a beam of length 20 meters. It is supported by rollers at both of its ends. A linear load having slope equal to 12 is applied along y-axis. A constant distributed load of magnitude 15 N is applied from start till its end along z-axis. .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A, x = symbols('l, E, G, I, A, x') >>> b = Beam3D(20, 40, 21, 100, 25, x) >>> b.apply_load(15, start=0, order=0, dir="z") >>> b.apply_load(12*x, start=0, order=0, dir="y") >>> b.bc_deflection = [(0, [0, 0, 0]), (20, [0, 0, 0])] >>> R1, R2, R3, R4 = symbols('R1, R2, R3, R4') >>> b.apply_load(R1, start=0, order=-1, dir="z") >>> b.apply_load(R2, start=20, order=-1, dir="z") >>> b.apply_load(R3, start=0, order=-1, dir="y") >>> b.apply_load(R4, start=20, order=-1, dir="y") >>> b.solve_for_reaction_loads(R1, R2, R3, R4) >>> b.solve_slope_deflection() >>> b.max_deflection() [(0, 0), (10, 495/14), (-10 + 10*sqrt(10793)/43, (10 - 10*sqrt(10793)/43)**3/160 - 20/7 + (10 - 10*sqrt(10793)/43)**4/6400 + 20*sqrt(10793)/301 + 27*(10 - 10*sqrt(10793)/43)**2/560)] r/rr)rr)rGrrIrIrJrks %zBeam3D.max_deflection)rrr\)rN)r/N)1rrrrrrKrrrr7r<rrrtrrrrrrrrrrrrrr2r1rrr,rr2rr7rr;rBr r%r rrrrrr __classcell__rIrIrrJrv sp6&           & ) 0  $D   H  H  I  J D H")")"r)7r sympy.corerrrrsympy.core.addrsympy.core.exprrsympy.core.functionrr sympy.core.mulr sympy.core.relationalr sympy.core.sympifyr sympy.solversrsympy.solvers.ode.odersympy.solvers.solversrsympy.printingrsympy.functionsrrrsympy.integralsr sympy.seriesrsympy.plottingrrsympy.geometry.entityrsympy.externalrsympy.sets.setsrsympy.utilities.lambdifyrsympy.utilities.decoratorrsympy.utilities.iterablesrr__doctest_requires__r)r-rrIrIrIrJs^                  [