\hJ"SSKJrJr SSKJrJrJr SSKJr SSK J r SSK J r SSK JrJrJrJrJr SSKJr SSKJr /S Qr"S S \5r"S S \5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5rg))ABCabstractmethod)pi DerivativeMatrix) AppliedUndef)BodyBase)_validate_coordinates)VectordynamicsymbolscrossPointReferenceFrame)iterable)sympy_deprecation_warning)JointPinJointPrismaticJointCylindricalJoint PlanarJointSphericalJoint WeldJointc\rSrSrSrS!SjrSrSr\S5r \S5r \S 5r \S 5r \S 5r \S 5r\S 5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S"Sj5rSr S#Sjr!S#Sjr"S$Sjr#S r$g)%raAbstract base class for all specific joints. Explanation =========== A joint subtracts degrees of freedom from a body. This is the base class for all specific joints and holds all common methods acting as an interface for all joints. Custom joint can be created by inheriting Joint class and defining all abstract functions. The abstract methods are: - ``_generate_coordinates`` - ``_generate_speeds`` - ``_orient_frames`` - ``_set_angular_velocity`` - ``_set_linear_velocity`` Parameters ========== name : string A unique name for the joint. parent : Particle or RigidBody The parent body of joint. child : Particle or RigidBody The child body of joint. coordinates : iterable of dynamicsymbols, optional Generalized coordinates of the joint. speeds : iterable of dynamicsymbols, optional Generalized speeds of joint. parent_point : Point or Vector, optional Attachment point where the joint is fixed to the parent body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the parent's mass center. child_point : Point or Vector, optional Attachment point where the joint is fixed to the child body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the child's mass center. parent_axis : Vector, optional .. deprecated:: 1.12 Axis fixed in the parent body which aligns with an axis fixed in the child body. The default is the x axis of parent's reference frame. For more information on this deprecation, see :ref:`deprecated-mechanics-joint-axis`. child_axis : Vector, optional .. deprecated:: 1.12 Axis fixed in the child body which aligns with an axis fixed in the parent body. The default is the x axis of child's reference frame. For more information on this deprecation, see :ref:`deprecated-mechanics-joint-axis`. parent_interframe : ReferenceFrame, optional Intermediate frame of the parent body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the parent's own frame. child_interframe : ReferenceFrame, optional Intermediate frame of the child body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the child's own frame. parent_joint_pos : Point or Vector, optional .. deprecated:: 1.12 This argument is replaced by parent_point and will be removed in a future version. See :ref:`deprecated-mechanics-joint-pos` for more information. child_joint_pos : Point or Vector, optional .. deprecated:: 1.12 This argument is replaced by child_point and will be removed in a future version. See :ref:`deprecated-mechanics-joint-pos` for more information. Attributes ========== name : string The joint's name. parent : Particle or RigidBody The joint's parent body. child : Particle or RigidBody The joint's child body. coordinates : Matrix Matrix of the joint's generalized coordinates. speeds : Matrix Matrix of the joint's generalized speeds. parent_point : Point Attachment point where the joint is fixed to the parent body. child_point : Point Attachment point where the joint is fixed to the child body. parent_axis : Vector The axis fixed in the parent frame that represents the joint. child_axis : Vector The axis fixed in the child frame that represents the joint. parent_interframe : ReferenceFrame Intermediate frame of the parent body with respect to which the joint transformation is formulated. child_interframe : ReferenceFrame Intermediate frame of the child body with respect to which the joint transformation is formulated. kdes : Matrix Kinematical differential equations of the joint. Notes ===== When providing a vector as the intermediate frame, a new intermediate frame is created which aligns its X axis with the provided vector. This is done with a single fixed rotation about a rotation axis. This rotation axis is determined by taking the cross product of the ``body.x`` axis with the provided vector. In the case where the provided vector is in the ``-body.x`` direction, the rotation is done about the ``body.y`` axis. Ncn[U[5(d [S5eXl[U[5(d [S5eX l[U[5(d [S5eX0lU cU b[SSSSS9 UcU nU cU n [UR S 5(aUR RUl OP[U[5(aXl O4[URS UR RS 35Ul [UR S 5(aUR RUl OP[U [5(aXl O4[URS UR RS 35Ul URUR XR5UlURUR XR5UlUR#XR5UlUR#XR5UlU cU b[S SS SS9 UcU nUcU nUR)UR X`R5UlUR)UR XpR5UlUR/U5UlUR3U5Ul[7UR8UR:5 UR=5UlURA5 URC5 URE5 g)NzSupply a valid name.zParent must be a body.zChild must be a body.z The parent_axis and child_axis arguments for the Joint classes are deprecated. Instead use parent_interframe, child_interframe. z1.12zdeprecated-mechanics-joint-axis)deprecated_since_versionactive_deprecations_target stacklevelframe__framez The parent_joint_pos and child_joint_pos arguments for the Joint classes are deprecated. Instead use parent_point and child_point. zdeprecated-mechanics-joint-pos)# isinstancestr TypeError_namer _parent_childrhasattrr _parent_framername _child_frame_locate_joint_frame_parent_interframe_child_interframe_axis _parent_axis _child_axis_locate_joint_pos _parent_point _child_point_generate_coordinates _coordinates_generate_speeds_speedsr coordinatesspeeds_generate_kdes_kdes_orient_frames_set_angular_velocity_set_linear_velocity)selfr+parentchildr:r; parent_point child_pointparent_interframechild_interframe parent_axis child_axisparent_joint_poschild_joint_poss U/var/www/auris/envauris/lib/python3.13/site-packages/sympy/physics/mechanics/joint.py__init__Joint.__init__s $$$23 3 &(++45 5 %**34 4  "j&< %*0+L !($/!'#-  4<< ) )!%!3!3D +^<<%6"%3yyk4<<#4#4"5V<&>" 4;; ( ( $ 1 1D *N;;$4!$2yyk4;;#3#3"4F;%=!#'":": LL+-?-?#A!%!9!9 KK)+<+<"> JJ{4F4FG::j2C2CD  '?+F %*0+K #/ "- !33 LL,(:(:< 22 KK&7&79!66{C,,V4 d.. <((*   ""$ !!#cUR$N)r+rAs rL__str__ Joint.__str__s yyrOc"UR5$rQ)rSrRs rL__repr__Joint.__repr__s||~rOcUR$)zName of the joint.)r&rRs rLr+ Joint.namezzrOcUR$)zParent body of Joint.)r'rRs rLrB Joint.parent||rOcUR$)zChild body of Joint.)r(rRs rLrC Joint.childs{{rOcUR$)z.Matrix of the joint's generalized coordinates.)r7rRs rLr:Joint.coordinates   rOcUR$)z)Matrix of the joint's generalized speeds.)r9rRs rLr; Joint.speedsr]rOcUR$)z0Kinematical differential equations of the joint.r=rRs rLkdes Joint.kdesrZrOcUR$)zThe axis of parent frame.)r1rRs rLrHJoint.parent_axiss   rOcUR$)zThe axis of child frame.)r2rRs rLrIJoint.child_axissrOcUR$)z=Attachment point where the joint is fixed to the parent body.)r4rRs rLrDJoint.parent_point s!!!rOcUR$)zJoint._orient_frames(ryrOcg)z1Set angular velocity of the joint related frames.NrvrRs rLr?Joint._set_angular_velocity-ryrOcg)z,Set velocity of related points to the joint.NrvrRs rLr@Joint._set_linear_velocity2ryrOc[X4/5$)z1Converts a matrix to a vector in the given frame.)r )matrixr s rL _to_vectorJoint._to_vector7s'((rOc*UcUSRnU$[U[5(d [S5eSnUHnUR U5 Un O Uc [ S5eUR U5S:Xd [ S5eU$![ a MXf=f)z4Check whether an axis is fixed in one of the frames.NrzAxis must be a Vector.z5Axis cannot be expressed in one of the body's frames.zAAxis cannot be time-varying when viewed from the associated body.)xr#r r% to_matrix ValueErrordt)axframes ref_framer s rLr0 Joint._axis<s :BI"f%%45 5 E  U#"   '( (uuY1$01 1   sB BBcURU5nUSUSUSpTnUS:wa?US:waUS:wa[XR5$US:wa UR$UR$US:wa UR$UR$)Nr)rr ryz)r axis componentsrrrs rL_choose_rotation_axisJoint._choose_rotation_axisUs}^^E* Q-A 1 a 6Av6 ww//Avww77NAvww77NrOc[U[5(a URnUc URnUc5URSSS:XaURSSS3nOURS3nUR U5n[ X!5nU[S5:XaUS:XaU$U[:Xa[RX5n[U5nURXU5 URUSU-5 U$)u Returns an intermediate frame, where the ``frame_axis`` defined in ``frame`` is aligned with ``axis``. By default this means that the X axis will be aligned with ``axis``. Parameters ========== frame : BodyBase or ReferenceFrame The body or reference frame with respect to which the intermediate frame is oriented. align_axis : Vector The vector with respect to which the intermediate frame will be aligned. frame_axis : Vector The vector of the frame which should get aligned with ``axis``. The default is the X axis of the frame. frame_name : string Name of the to be created intermediate frame. The default adds "_int_frame" to the name of ``frame``. Example ======= An intermediate frame, where the X axis of the parent becomes aligned with ``parent.y + parent.z`` can be created as follows: >>> from sympy.physics.mechanics.joint import Joint >>> from sympy.physics.mechanics import RigidBody >>> parent = RigidBody('parent') >>> parent_interframe = Joint._create_aligned_interframe( ... parent, parent.y + parent.z) >>> parent_interframe parent_int_frame >>> parent.frame.dcm(parent_interframe) Matrix([ [ 0, -sqrt(2)/2, -sqrt(2)/2], [sqrt(2)/2, 1/2, -1/2], [sqrt(2)/2, -1/2, 1/2]]) >>> (parent.y + parent.z).express(parent_interframe) sqrt(2)*parent_int_frame.x Notes ===== The direction cosine matrix between the given frame and intermediate frame is formed using a simple rotation about an axis that is normal to both ``align_axis`` and ``frame_axis``. In general, the normal axis is formed by crossing the ``frame_axis`` with the ``align_axis``. The exception is if the axes are parallel with opposite directions, in which case the rotation vector is chosen using the rules in the following table with the vectors expressed in the given frame: .. list-table:: :header-rows: 1 * - ``align_axis`` - ``frame_axis`` - ``rotation_axis`` * - ``-x`` - ``x`` - ``z`` * - ``-y`` - ``y`` - ``x`` * - ``-z`` - ``z`` - ``y`` * - ``-x-y`` - ``x+y`` - ``z`` * - ``-y-z`` - ``y+z`` - ``x`` * - ``-x-z`` - ``x+z`` - ``y`` * - ``-x-y-z`` - ``x+y+z`` - ``(x+y+z) × x`` Nir" _int_framer)r#r r rr+ angle_betweenr r rrrr orient_axis set_ang_vel)r align_axis frame_axis frame_nameangle rotation_axis int_frames rL_create_aligned_interframe Joint._create_aligned_interframefsj eX & &KKE  J  zz"#(* % 3B0 ; % |:6 ((4j5 F1I %%1*L B;!77JM":. eE:eQ%67rOc/n[Rn[[UR55HAnUR URUR U5*URU-5 MC [U5$)z,Generate kinematical differential equations.) r _trangelenr:appenddiffr;r)rArgtis rLr<Joint._generate_kdessh   s4++,-A KK))!,11!44t{{1~E F.d|rOcUc URnUc UR$[U[[45(d [ S5e[U[5(a7UR SUR S3nURRXB5nURUR5RU5S:Xd [S5eU$)z'Returns the attachment point of a body.z+Attachment point must be a Point or Vector.r!_jointrz6Attachment point must be fixed to the associated body.) r masscenterr#rr r%r+ locatenewpos_fromrr)rAbody joint_pos body_frame point_names rLr3Joint._locate_joint_poss  J  ?? ")eV_55IJ J i ( ( II;a {&9J11*HI!!$//255jAQF%& &rOc|Uc URnUcU$[U[5(a/[R X2UR SUR S3S9nO [U[ 5(d [S5eURU5S:Xd[SUSUS35eURRUS5 U$) z'Returns the attachment frame of a body.r!r)rz$Interframe must be a ReferenceFrame.rz Interframe z is not fixed to body .) r r#r rrr+rr% ang_vel_inrrset_vel)rAr interframers rLr-Joint._locate_joint_frames  J    j& ) )99"ii[$))J?:AJJ77BC C$$Z0A5{:,6L $vQ() )  A.rOc L^^^^UUUU4SjnTS:XaSOSn/nUc/nO[U5(dU/n[U5S:Xd0[U5T:Xd![STSUS[U5SUS 3 5e[U5HaupU cUR U"X-55 M#[ U [ [45(aUR U 5 MQ[S USU S 35e [[U5U-TU-5Hn UR U"U 55 M [U5$) a-Helper method for _generate_coordinates and _generate_speeds. Parameters ========== coordinates : iterable Iterable of coordinates or speeds that have been provided. n_coords : Integer Number of coordinates that should be returned. label : String, optional Coordinate type either 'q' (coordinates) or 'u' (speeds). The Default is 'q'. offset : Integer Count offset when creating new dynamicsymbols. The default is 0. number_single : Boolean Boolean whether if n_coords == 1, number should still be used. The default is False. c>TS:Xa!T(d[TSTR35$[TUSTR35$)Nrr!)r r+)numberlabeln_coords number_singlerAs rL create_symbol2Joint._fill_coordinate_list..create_symbolsD1}]%q &<==!UGF81TYYK"@A ArOqzgeneralized coordinatezgeneralized speedrz Expected  zs, instead got zs.zThe z" should have been a dynamicsymbol.) rrr enumeraterr#rrr%rr) rAr:rroffsetrrr+generated_coordinatesrcoords ` `` ` rL_fill_coordinate_listJoint._fill_coordinate_listsA, B B ,1C<'=P "  K+&&&-KK A%[)9X)Ey !D6 #K 014&<= ="+.HA}%,,]1:-FGEL*#=>>%,,U3$tfAeW51!233 /s;'&0(V2CDA ! ( (q)9 :E+,,rO)r(r2r,r/r5r7r=r&r'r1r*r.r4r9) NNNNNNNNNN)NNrQ)rrF)%__name__ __module__ __qualname____firstlineno____doc__rMrSrVpropertyr+rBrCr:r;rgrHrIrDrErFrGrr6r8r>r?r@ staticmethodrr0rrr<r3r-r__static_attributes__rvrOrLrrsrhFJHLEI8<S$j!!!!   ""!!''&&          ))0 AE.2ggR $NO,1/-rOrcl^\rSrSrSrS U4SjjrSr\S5rSr Sr Sr S r S r S rU=r$) ri,uPin (Revolute) Joint. .. raw:: html :file: ../../../doc/src/explanation/modules/physics/mechanics/PinJoint.svg Explanation =========== A pin joint is defined such that the joint rotation axis is fixed in both the child and parent and the location of the joint is relative to the mass center of each body. The child rotates an angle, θ, from the parent about the rotation axis and has a simple angular speed, ω, relative to the parent. The direction cosine matrix between the child interframe and parent interframe is formed using a simple rotation about the joint axis. The page on the joints framework gives a more detailed explanation of the intermediate frames. Parameters ========== name : string A unique name for the joint. parent : Particle or RigidBody The parent body of joint. child : Particle or RigidBody The child body of joint. coordinates : dynamicsymbol, optional Generalized coordinates of the joint. speeds : dynamicsymbol, optional Generalized speeds of joint. parent_point : Point or Vector, optional Attachment point where the joint is fixed to the parent body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the parent's mass center. child_point : Point or Vector, optional Attachment point where the joint is fixed to the child body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the child's mass center. parent_axis : Vector, optional .. deprecated:: 1.12 Axis fixed in the parent body which aligns with an axis fixed in the child body. The default is the x axis of parent's reference frame. For more information on this deprecation, see :ref:`deprecated-mechanics-joint-axis`. child_axis : Vector, optional .. deprecated:: 1.12 Axis fixed in the child body which aligns with an axis fixed in the parent body. The default is the x axis of child's reference frame. For more information on this deprecation, see :ref:`deprecated-mechanics-joint-axis`. parent_interframe : ReferenceFrame, optional Intermediate frame of the parent body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the parent's own frame. child_interframe : ReferenceFrame, optional Intermediate frame of the child body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the child's own frame. joint_axis : Vector The axis about which the rotation occurs. Note that the components of this axis are the same in the parent_interframe and child_interframe. parent_joint_pos : Point or Vector, optional .. deprecated:: 1.12 This argument is replaced by parent_point and will be removed in a future version. See :ref:`deprecated-mechanics-joint-pos` for more information. child_joint_pos : Point or Vector, optional .. deprecated:: 1.12 This argument is replaced by child_point and will be removed in a future version. See :ref:`deprecated-mechanics-joint-pos` for more information. Attributes ========== name : string The joint's name. parent : Particle or RigidBody The joint's parent body. child : Particle or RigidBody The joint's child body. coordinates : Matrix Matrix of the joint's generalized coordinates. The default value is ``dynamicsymbols(f'q_{joint.name}')``. speeds : Matrix Matrix of the joint's generalized speeds. The default value is ``dynamicsymbols(f'u_{joint.name}')``. parent_point : Point Attachment point where the joint is fixed to the parent body. child_point : Point Attachment point where the joint is fixed to the child body. parent_axis : Vector The axis fixed in the parent frame that represents the joint. child_axis : Vector The axis fixed in the child frame that represents the joint. parent_interframe : ReferenceFrame Intermediate frame of the parent body with respect to which the joint transformation is formulated. child_interframe : ReferenceFrame Intermediate frame of the child body with respect to which the joint transformation is formulated. joint_axis : Vector The axis about which the rotation occurs. Note that the components of this axis are the same in the parent_interframe and child_interframe. kdes : Matrix Kinematical differential equations of the joint. Examples ========= A single pin joint is created from two bodies and has the following basic attributes: >>> from sympy.physics.mechanics import RigidBody, PinJoint >>> parent = RigidBody('P') >>> parent P >>> child = RigidBody('C') >>> child C >>> joint = PinJoint('PC', parent, child) >>> joint PinJoint: PC parent: P child: C >>> joint.name 'PC' >>> joint.parent P >>> joint.child C >>> joint.parent_point P_masscenter >>> joint.child_point C_masscenter >>> joint.parent_axis P_frame.x >>> joint.child_axis C_frame.x >>> joint.coordinates Matrix([[q_PC(t)]]) >>> joint.speeds Matrix([[u_PC(t)]]) >>> child.frame.ang_vel_in(parent.frame) u_PC(t)*P_frame.x >>> child.frame.dcm(parent.frame) Matrix([ [1, 0, 0], [0, cos(q_PC(t)), sin(q_PC(t))], [0, -sin(q_PC(t)), cos(q_PC(t))]]) >>> joint.child_point.pos_from(joint.parent_point) 0 To further demonstrate the use of the pin joint, the kinematics of simple double pendulum that rotates about the Z axis of each connected body can be created as follows. >>> from sympy import symbols, trigsimp >>> from sympy.physics.mechanics import RigidBody, PinJoint >>> l1, l2 = symbols('l1 l2') First create bodies to represent the fixed ceiling and one to represent each pendulum bob. >>> ceiling = RigidBody('C') >>> upper_bob = RigidBody('U') >>> lower_bob = RigidBody('L') The first joint will connect the upper bob to the ceiling by a distance of ``l1`` and the joint axis will be about the Z axis for each body. >>> ceiling_joint = PinJoint('P1', ceiling, upper_bob, ... child_point=-l1*upper_bob.frame.x, ... joint_axis=ceiling.frame.z) The second joint will connect the lower bob to the upper bob by a distance of ``l2`` and the joint axis will also be about the Z axis for each body. >>> pendulum_joint = PinJoint('P2', upper_bob, lower_bob, ... child_point=-l2*lower_bob.frame.x, ... joint_axis=upper_bob.frame.z) Once the joints are established the kinematics of the connected bodies can be accessed. First the direction cosine matrices of pendulum link relative to the ceiling are found: >>> upper_bob.frame.dcm(ceiling.frame) Matrix([ [ cos(q_P1(t)), sin(q_P1(t)), 0], [-sin(q_P1(t)), cos(q_P1(t)), 0], [ 0, 0, 1]]) >>> trigsimp(lower_bob.frame.dcm(ceiling.frame)) Matrix([ [ cos(q_P1(t) + q_P2(t)), sin(q_P1(t) + q_P2(t)), 0], [-sin(q_P1(t) + q_P2(t)), cos(q_P1(t) + q_P2(t)), 0], [ 0, 0, 1]]) The position of the lower bob's masscenter is found with: >>> lower_bob.masscenter.pos_from(ceiling.masscenter) l1*U_frame.x + l2*L_frame.x The angular velocities of the two pendulum links can be computed with respect to the ceiling. >>> upper_bob.frame.ang_vel_in(ceiling.frame) u_P1(t)*C_frame.z >>> lower_bob.frame.ang_vel_in(ceiling.frame) u_P1(t)*C_frame.z + u_P2(t)*U_frame.z And finally, the linear velocities of the two pendulum bobs can be computed with respect to the ceiling. >>> upper_bob.masscenter.vel(ceiling.frame) l1*u_P1(t)*U_frame.y >>> lower_bob.masscenter.vel(ceiling.frame) l1*u_P1(t)*U_frame.y + l2*(u_P1(t) + u_P2(t))*L_frame.y c>>Xl[TU] XX4XVXxU XU U5 grQ _joint_axissuperrMrAr+rBrCr:r;rDrErFrGrHrI joint_axisrJrK __class__s rLrMPinJoint.__init__ - & u6$9I$2B( *rOcTSURSURSUR3$)Nz PinJoint: parent: child: r+rBrCrRs rLrSPinJoint.__str__s/TYYKz$++?**' (rOcUR$)z>Axis about which the child rotates with respect to the parent.rrRs rLrPinJoint.joint_axisrOc(URUSS5$NrrrrA coordinates rLr6PinJoint._generate_coordinates))*a==rOc(URUSS5$NrurrAspeeds rLr8PinJoint._generate_speeds"))%C88rOcURURUR5UlURR URURUR S5 gNr)r0rrFrrGrr:rRs rLr>PinJoint._orient_frames%sP::doot7M7MN ))  " "DOOT5E5Ea5H JrOcURRURURSURR 5-5 gr)rGrrFr;r normalizerRs rLr?PinJoint._set_angular_velocity*sC ))$*@*@$++ C**,C- .rOcrURRURS5 URRURS5 URRUR S5 UR RRURURUR 5 gr rEset_posrDrr*r,rCr v2pt_theoryrRs rLr@PinJoint._set_linear_velocity.s   !2!2A6 !!$"4"4a8   !2!2A6 ))$*;*;*.*<*O>O QrOr NNNNNNNNNNNrrrrrrMrSrrr6r8r>r?r@r __classcell__rs@rLrr,sY\|FJHLEIIM *(  >9J .QQrOrcl^\rSrSrSrS U4SjjrSr\S5rSr Sr Sr S r S r S rU=r$) ri6aPrismatic (Sliding) Joint. .. image:: PrismaticJoint.svg Explanation =========== It is defined such that the child body translates with respect to the parent body along the body-fixed joint axis. The location of the joint is defined by two points, one in each body, which coincide when the generalized coordinate is zero. The direction cosine matrix between the parent_interframe and child_interframe is the identity matrix. Therefore, the direction cosine matrix between the parent and child frames is fully defined by the definition of the intermediate frames. The page on the joints framework gives a more detailed explanation of the intermediate frames. Parameters ========== name : string A unique name for the joint. parent : Particle or RigidBody The parent body of joint. child : Particle or RigidBody The child body of joint. coordinates : dynamicsymbol, optional Generalized coordinates of the joint. The default value is ``dynamicsymbols(f'q_{joint.name}')``. speeds : dynamicsymbol, optional Generalized speeds of joint. The default value is ``dynamicsymbols(f'u_{joint.name}')``. parent_point : Point or Vector, optional Attachment point where the joint is fixed to the parent body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the parent's mass center. child_point : Point or Vector, optional Attachment point where the joint is fixed to the child body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the child's mass center. parent_axis : Vector, optional .. deprecated:: 1.12 Axis fixed in the parent body which aligns with an axis fixed in the child body. The default is the x axis of parent's reference frame. For more information on this deprecation, see :ref:`deprecated-mechanics-joint-axis`. child_axis : Vector, optional .. deprecated:: 1.12 Axis fixed in the child body which aligns with an axis fixed in the parent body. The default is the x axis of child's reference frame. For more information on this deprecation, see :ref:`deprecated-mechanics-joint-axis`. parent_interframe : ReferenceFrame, optional Intermediate frame of the parent body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the parent's own frame. child_interframe : ReferenceFrame, optional Intermediate frame of the child body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the child's own frame. joint_axis : Vector The axis along which the translation occurs. Note that the components of this axis are the same in the parent_interframe and child_interframe. parent_joint_pos : Point or Vector, optional .. deprecated:: 1.12 This argument is replaced by parent_point and will be removed in a future version. See :ref:`deprecated-mechanics-joint-pos` for more information. child_joint_pos : Point or Vector, optional .. deprecated:: 1.12 This argument is replaced by child_point and will be removed in a future version. See :ref:`deprecated-mechanics-joint-pos` for more information. Attributes ========== name : string The joint's name. parent : Particle or RigidBody The joint's parent body. child : Particle or RigidBody The joint's child body. coordinates : Matrix Matrix of the joint's generalized coordinates. speeds : Matrix Matrix of the joint's generalized speeds. parent_point : Point Attachment point where the joint is fixed to the parent body. child_point : Point Attachment point where the joint is fixed to the child body. parent_axis : Vector The axis fixed in the parent frame that represents the joint. child_axis : Vector The axis fixed in the child frame that represents the joint. parent_interframe : ReferenceFrame Intermediate frame of the parent body with respect to which the joint transformation is formulated. child_interframe : ReferenceFrame Intermediate frame of the child body with respect to which the joint transformation is formulated. kdes : Matrix Kinematical differential equations of the joint. Examples ========= A single prismatic joint is created from two bodies and has the following basic attributes: >>> from sympy.physics.mechanics import RigidBody, PrismaticJoint >>> parent = RigidBody('P') >>> parent P >>> child = RigidBody('C') >>> child C >>> joint = PrismaticJoint('PC', parent, child) >>> joint PrismaticJoint: PC parent: P child: C >>> joint.name 'PC' >>> joint.parent P >>> joint.child C >>> joint.parent_point P_masscenter >>> joint.child_point C_masscenter >>> joint.parent_axis P_frame.x >>> joint.child_axis C_frame.x >>> joint.coordinates Matrix([[q_PC(t)]]) >>> joint.speeds Matrix([[u_PC(t)]]) >>> child.frame.ang_vel_in(parent.frame) 0 >>> child.frame.dcm(parent.frame) Matrix([ [1, 0, 0], [0, 1, 0], [0, 0, 1]]) >>> joint.child_point.pos_from(joint.parent_point) q_PC(t)*P_frame.x To further demonstrate the use of the prismatic joint, the kinematics of two masses sliding, one moving relative to a fixed body and the other relative to the moving body. about the X axis of each connected body can be created as follows. >>> from sympy.physics.mechanics import PrismaticJoint, RigidBody First create bodies to represent the fixed ceiling and one to represent a particle. >>> wall = RigidBody('W') >>> Part1 = RigidBody('P1') >>> Part2 = RigidBody('P2') The first joint will connect the particle to the ceiling and the joint axis will be about the X axis for each body. >>> J1 = PrismaticJoint('J1', wall, Part1) The second joint will connect the second particle to the first particle and the joint axis will also be about the X axis for each body. >>> J2 = PrismaticJoint('J2', Part1, Part2) Once the joint is established the kinematics of the connected bodies can be accessed. First the direction cosine matrices of Part relative to the ceiling are found: >>> Part1.frame.dcm(wall.frame) Matrix([ [1, 0, 0], [0, 1, 0], [0, 0, 1]]) >>> Part2.frame.dcm(wall.frame) Matrix([ [1, 0, 0], [0, 1, 0], [0, 0, 1]]) The position of the particles' masscenter is found with: >>> Part1.masscenter.pos_from(wall.masscenter) q_J1(t)*W_frame.x >>> Part2.masscenter.pos_from(wall.masscenter) q_J1(t)*W_frame.x + q_J2(t)*P1_frame.x The angular velocities of the two particle links can be computed with respect to the ceiling. >>> Part1.frame.ang_vel_in(wall.frame) 0 >>> Part2.frame.ang_vel_in(wall.frame) 0 And finally, the linear velocities of the two particles can be computed with respect to the ceiling. >>> Part1.masscenter.vel(wall.frame) u_J1(t)*W_frame.x >>> Part2.masscenter.vel(wall.frame) u_J1(t)*W_frame.x + Derivative(q_J2(t), t)*P1_frame.x c>>Xl[TU] XX4XVXxU XU U5 grQrrs rLrMPrismaticJoint.__init__rrOcTSURSURSUR3$)NzPrismaticJoint: rrrrRs rLrSPrismaticJoint.__str__0"499+Z }E**' (rOcUR$)zAAxis along which the child translates with respect to the parent.rrRs rLrPrismaticJoint.joint_axis!rrOc(URUSS5$rrrs rLr6$PrismaticJoint._generate_coordinates&rrOc(URUSS5$rrrs rLr8PrismaticJoint._generate_speeds)rrOcURURUR5UlURR URURS5 gr)r0rrFrrGrrRs rLr>PrismaticJoint._orient_frames,sD::doot7M7MN ))  " "DOOQ 8rOcPURRURS5 grrGrrFrRs rLr?$PrismaticJoint._set_angular_velocity1 ))$*@*@!DrOc(URR5nURRURUR SU-5 URR URS5 URR URS5 URR URURSU-5 URRR URURSU-5 gr) rrrErrDr:rr*r,r;rCr)rArs rLr@#PrismaticJoint._set_linear_velocity4s((*   !2!2D4D4DQ4G$4NO !!$"4"4a8   !2!2A6   !3!3T[[^d5JK %%d&8&8$++a.4:OPrOrrrrs@rLrr6sYYvFJHLEIIM *(  >98 EQQrOrc^\rSrSrSrSU4SjjrSr\S5r\S5r \S5r \S5r \S 5r S r S rS rS rSrSrU=r$)ri=aCylindrical Joint. .. image:: CylindricalJoint.svg :align: center :width: 600 Explanation =========== A cylindrical joint is defined such that the child body both rotates about and translates along the body-fixed joint axis with respect to the parent body. The joint axis is both the rotation axis and translation axis. The location of the joint is defined by two points, one in each body, which coincide when the generalized coordinate corresponding to the translation is zero. The direction cosine matrix between the child interframe and parent interframe is formed using a simple rotation about the joint axis. The page on the joints framework gives a more detailed explanation of the intermediate frames. Parameters ========== name : string A unique name for the joint. parent : Particle or RigidBody The parent body of joint. child : Particle or RigidBody The child body of joint. rotation_coordinate : dynamicsymbol, optional Generalized coordinate corresponding to the rotation angle. The default value is ``dynamicsymbols(f'q0_{joint.name}')``. translation_coordinate : dynamicsymbol, optional Generalized coordinate corresponding to the translation distance. The default value is ``dynamicsymbols(f'q1_{joint.name}')``. rotation_speed : dynamicsymbol, optional Generalized speed corresponding to the angular velocity. The default value is ``dynamicsymbols(f'u0_{joint.name}')``. translation_speed : dynamicsymbol, optional Generalized speed corresponding to the translation velocity. The default value is ``dynamicsymbols(f'u1_{joint.name}')``. parent_point : Point or Vector, optional Attachment point where the joint is fixed to the parent body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the parent's mass center. child_point : Point or Vector, optional Attachment point where the joint is fixed to the child body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the child's mass center. parent_interframe : ReferenceFrame, optional Intermediate frame of the parent body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the parent's own frame. child_interframe : ReferenceFrame, optional Intermediate frame of the child body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the child's own frame. joint_axis : Vector, optional The rotation as well as translation axis. Note that the components of this axis are the same in the parent_interframe and child_interframe. Attributes ========== name : string The joint's name. parent : Particle or RigidBody The joint's parent body. child : Particle or RigidBody The joint's child body. rotation_coordinate : dynamicsymbol Generalized coordinate corresponding to the rotation angle. translation_coordinate : dynamicsymbol Generalized coordinate corresponding to the translation distance. rotation_speed : dynamicsymbol Generalized speed corresponding to the angular velocity. translation_speed : dynamicsymbol Generalized speed corresponding to the translation velocity. coordinates : Matrix Matrix of the joint's generalized coordinates. speeds : Matrix Matrix of the joint's generalized speeds. parent_point : Point Attachment point where the joint is fixed to the parent body. child_point : Point Attachment point where the joint is fixed to the child body. parent_interframe : ReferenceFrame Intermediate frame of the parent body with respect to which the joint transformation is formulated. child_interframe : ReferenceFrame Intermediate frame of the child body with respect to which the joint transformation is formulated. kdes : Matrix Kinematical differential equations of the joint. joint_axis : Vector The axis of rotation and translation. Examples ========= A single cylindrical joint is created between two bodies and has the following basic attributes: >>> from sympy.physics.mechanics import RigidBody, CylindricalJoint >>> parent = RigidBody('P') >>> parent P >>> child = RigidBody('C') >>> child C >>> joint = CylindricalJoint('PC', parent, child) >>> joint CylindricalJoint: PC parent: P child: C >>> joint.name 'PC' >>> joint.parent P >>> joint.child C >>> joint.parent_point P_masscenter >>> joint.child_point C_masscenter >>> joint.parent_axis P_frame.x >>> joint.child_axis C_frame.x >>> joint.coordinates Matrix([ [q0_PC(t)], [q1_PC(t)]]) >>> joint.speeds Matrix([ [u0_PC(t)], [u1_PC(t)]]) >>> child.frame.ang_vel_in(parent.frame) u0_PC(t)*P_frame.x >>> child.frame.dcm(parent.frame) Matrix([ [1, 0, 0], [0, cos(q0_PC(t)), sin(q0_PC(t))], [0, -sin(q0_PC(t)), cos(q0_PC(t))]]) >>> joint.child_point.pos_from(joint.parent_point) q1_PC(t)*P_frame.x >>> child.masscenter.vel(parent.frame) u1_PC(t)*P_frame.x To further demonstrate the use of the cylindrical joint, the kinematics of two cylindrical joints perpendicular to each other can be created as follows. >>> from sympy import symbols >>> from sympy.physics.mechanics import RigidBody, CylindricalJoint >>> r, l, w = symbols('r l w') First create bodies to represent the fixed floor with a fixed pole on it. The second body represents a freely moving tube around that pole. The third body represents a solid flag freely translating along and rotating around the Y axis of the tube. >>> floor = RigidBody('floor') >>> tube = RigidBody('tube') >>> flag = RigidBody('flag') The first joint will connect the first tube to the floor with it translating along and rotating around the Z axis of both bodies. >>> floor_joint = CylindricalJoint('C1', floor, tube, joint_axis=floor.z) The second joint will connect the tube perpendicular to the flag along the Y axis of both the tube and the flag, with the joint located at a distance ``r`` from the tube's center of mass and a combination of the distances ``l`` and ``w`` from the flag's center of mass. >>> flag_joint = CylindricalJoint('C2', tube, flag, ... parent_point=r * tube.y, ... child_point=-w * flag.y + l * flag.z, ... joint_axis=tube.y) Once the joints are established the kinematics of the connected bodies can be accessed. First the direction cosine matrices of both the body and the flag relative to the floor are found: >>> tube.frame.dcm(floor.frame) Matrix([ [ cos(q0_C1(t)), sin(q0_C1(t)), 0], [-sin(q0_C1(t)), cos(q0_C1(t)), 0], [ 0, 0, 1]]) >>> flag.frame.dcm(floor.frame) Matrix([ [cos(q0_C1(t))*cos(q0_C2(t)), sin(q0_C1(t))*cos(q0_C2(t)), -sin(q0_C2(t))], [ -sin(q0_C1(t)), cos(q0_C1(t)), 0], [sin(q0_C2(t))*cos(q0_C1(t)), sin(q0_C1(t))*sin(q0_C2(t)), cos(q0_C2(t))]]) The position of the flag's center of mass is found with: >>> flag.masscenter.pos_from(floor.masscenter) q1_C1(t)*floor_frame.z + (r + q1_C2(t))*tube_frame.y + w*flag_frame.y - l*flag_frame.z The angular velocities of the two tubes can be computed with respect to the floor. >>> tube.frame.ang_vel_in(floor.frame) u0_C1(t)*floor_frame.z >>> flag.frame.ang_vel_in(floor.frame) u0_C1(t)*floor_frame.z + u0_C2(t)*tube_frame.y Finally, the linear velocities of the two tube centers of mass can be computed with respect to the floor, while expressed in the tube's frame. >>> tube.masscenter.vel(floor.frame).to_matrix(tube.frame) Matrix([ [ 0], [ 0], [u1_C1(t)]]) >>> flag.masscenter.vel(floor.frame).to_matrix(tube.frame).simplify() Matrix([ [-l*u0_C2(t)*cos(q0_C2(t)) - r*u0_C1(t) - w*u0_C1(t) - q1_C2(t)*u0_C1(t)], [ -l*u0_C1(t)*sin(q0_C2(t)) + Derivative(q1_C2(t), t)], [ l*u0_C2(t)*sin(q0_C2(t)) + u1_C1(t)]]) c B>XlXE4n Xg4n[TU] XX=UXU U S9 gNrFrGr)rAr+rBrCrotation_coordinatetranslation_coordinaterotation_speedtranslation_speedrDrErFrGrr:r;rs rLrMCylindricalJoint.__init__s< &*C  4 u6%+<*:  >rOc(URUSS5$)Nrrrr{s rLr8!CylindricalJoint._generate_speedsLs))&!S99rOcURURUR5UlURR URURUR 5 grQ)r0rrFrrGrrrRs rLr>CylindricalJoint._orient_framesOsK::doot7M7MN ))  " "DOOT5M5M OrOcURRURURURR 5-5 grQ)rGrrFr!rrrRs rLr?&CylindricalJoint._set_angular_velocityTs: ))  " "   $//";";"= = ?rOcRURRURURURR 5-5 URR URS5 URR URS5 URR URURURR 5-5 URRRURURUR5 gr)rErrDr rrrr*r,r"rCrrrGrRs rLr@%CylindricalJoint._set_linear_velocityYs       ' '$//*C*C*E E G !!$"4"4a8   !2!2A6       " "T__%>%>%@ @ B ))$*:*:Dr?r@rrrs@rLrr=s_BAE=AHL:> <(  ####?:O ? A ArOrc^\rSrSrSrSU4SjjrSr\S5r\S5r \S5r \S5r \S 5r \S 5r S rS rS rSrSrSrU=r$)rifa'Planar Joint. .. raw:: html :file: ../../../doc/src/modules/physics/mechanics/api/PlanarJoint.svg Explanation =========== A planar joint is defined such that the child body translates over a fixed plane of the parent body as well as rotate about the rotation axis, which is perpendicular to that plane. The origin of this plane is the ``parent_point`` and the plane is spanned by two nonparallel planar vectors. The location of the ``child_point`` is based on the planar vectors ($\vec{v}_1$, $\vec{v}_2$) and generalized coordinates ($q_1$, $q_2$), i.e. $\vec{r} = q_1 \hat{v}_1 + q_2 \hat{v}_2$. The direction cosine matrix between the ``child_interframe`` and ``parent_interframe`` is formed using a simple rotation ($q_0$) about the rotation axis. In order to simplify the definition of the ``PlanarJoint``, the ``rotation_axis`` and ``planar_vectors`` are set to be the unit vectors of the ``parent_interframe`` according to the table below. This ensures that you can only define these vectors by creating a separate frame and supplying that as the interframe. If you however would only like to supply the normals of the plane with respect to the parent and child bodies, then you can also supply those to the ``parent_interframe`` and ``child_interframe`` arguments. An example of both of these cases is in the examples section below and the page on the joints framework provides a more detailed explanation of the intermediate frames. .. list-table:: * - ``rotation_axis`` - ``parent_interframe.x`` * - ``planar_vectors[0]`` - ``parent_interframe.y`` * - ``planar_vectors[1]`` - ``parent_interframe.z`` Parameters ========== name : string A unique name for the joint. parent : Particle or RigidBody The parent body of joint. child : Particle or RigidBody The child body of joint. rotation_coordinate : dynamicsymbol, optional Generalized coordinate corresponding to the rotation angle. The default value is ``dynamicsymbols(f'q0_{joint.name}')``. planar_coordinates : iterable of dynamicsymbols, optional Two generalized coordinates used for the planar translation. The default value is ``dynamicsymbols(f'q1_{joint.name} q2_{joint.name}')``. rotation_speed : dynamicsymbol, optional Generalized speed corresponding to the angular velocity. The default value is ``dynamicsymbols(f'u0_{joint.name}')``. planar_speeds : dynamicsymbols, optional Two generalized speeds used for the planar translation velocity. The default value is ``dynamicsymbols(f'u1_{joint.name} u2_{joint.name}')``. parent_point : Point or Vector, optional Attachment point where the joint is fixed to the parent body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the parent's mass center. child_point : Point or Vector, optional Attachment point where the joint is fixed to the child body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the child's mass center. parent_interframe : ReferenceFrame, optional Intermediate frame of the parent body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the parent's own frame. child_interframe : ReferenceFrame, optional Intermediate frame of the child body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the child's own frame. Attributes ========== name : string The joint's name. parent : Particle or RigidBody The joint's parent body. child : Particle or RigidBody The joint's child body. rotation_coordinate : dynamicsymbol Generalized coordinate corresponding to the rotation angle. planar_coordinates : Matrix Two generalized coordinates used for the planar translation. rotation_speed : dynamicsymbol Generalized speed corresponding to the angular velocity. planar_speeds : Matrix Two generalized speeds used for the planar translation velocity. coordinates : Matrix Matrix of the joint's generalized coordinates. speeds : Matrix Matrix of the joint's generalized speeds. parent_point : Point Attachment point where the joint is fixed to the parent body. child_point : Point Attachment point where the joint is fixed to the child body. parent_interframe : ReferenceFrame Intermediate frame of the parent body with respect to which the joint transformation is formulated. child_interframe : ReferenceFrame Intermediate frame of the child body with respect to which the joint transformation is formulated. kdes : Matrix Kinematical differential equations of the joint. rotation_axis : Vector The axis about which the rotation occurs. planar_vectors : list The vectors that describe the planar translation directions. Examples ========= A single planar joint is created between two bodies and has the following basic attributes: >>> from sympy.physics.mechanics import RigidBody, PlanarJoint >>> parent = RigidBody('P') >>> parent P >>> child = RigidBody('C') >>> child C >>> joint = PlanarJoint('PC', parent, child) >>> joint PlanarJoint: PC parent: P child: C >>> joint.name 'PC' >>> joint.parent P >>> joint.child C >>> joint.parent_point P_masscenter >>> joint.child_point C_masscenter >>> joint.rotation_axis P_frame.x >>> joint.planar_vectors [P_frame.y, P_frame.z] >>> joint.rotation_coordinate q0_PC(t) >>> joint.planar_coordinates Matrix([ [q1_PC(t)], [q2_PC(t)]]) >>> joint.coordinates Matrix([ [q0_PC(t)], [q1_PC(t)], [q2_PC(t)]]) >>> joint.rotation_speed u0_PC(t) >>> joint.planar_speeds Matrix([ [u1_PC(t)], [u2_PC(t)]]) >>> joint.speeds Matrix([ [u0_PC(t)], [u1_PC(t)], [u2_PC(t)]]) >>> child.frame.ang_vel_in(parent.frame) u0_PC(t)*P_frame.x >>> child.frame.dcm(parent.frame) Matrix([ [1, 0, 0], [0, cos(q0_PC(t)), sin(q0_PC(t))], [0, -sin(q0_PC(t)), cos(q0_PC(t))]]) >>> joint.child_point.pos_from(joint.parent_point) q1_PC(t)*P_frame.y + q2_PC(t)*P_frame.z >>> child.masscenter.vel(parent.frame) u1_PC(t)*P_frame.y + u2_PC(t)*P_frame.z To further demonstrate the use of the planar joint, the kinematics of a block sliding on a slope, can be created as follows. >>> from sympy import symbols >>> from sympy.physics.mechanics import PlanarJoint, RigidBody, ReferenceFrame >>> a, d, h = symbols('a d h') First create bodies to represent the slope and the block. >>> ground = RigidBody('G') >>> block = RigidBody('B') To define the slope you can either define the plane by specifying the ``planar_vectors`` or/and the ``rotation_axis``. However it is advisable to create a rotated intermediate frame, so that the ``parent_vectors`` and ``rotation_axis`` will be the unit vectors of this intermediate frame. >>> slope = ReferenceFrame('A') >>> slope.orient_axis(ground.frame, ground.y, a) The planar joint can be created using these bodies and intermediate frame. We can specify the origin of the slope to be ``d`` above the slope's center of mass and the block's center of mass to be a distance ``h`` above the slope's surface. Note that we can specify the normal of the plane using the rotation axis argument. >>> joint = PlanarJoint('PC', ground, block, parent_point=d * ground.x, ... child_point=-h * block.x, parent_interframe=slope) Once the joint is established the kinematics of the bodies can be accessed. First the ``rotation_axis``, which is normal to the plane and the ``plane_vectors``, can be found. >>> joint.rotation_axis A.x >>> joint.planar_vectors [A.y, A.z] The direction cosine matrix of the block with respect to the ground can be found with: >>> block.frame.dcm(ground.frame) Matrix([ [ cos(a), 0, -sin(a)], [sin(a)*sin(q0_PC(t)), cos(q0_PC(t)), sin(q0_PC(t))*cos(a)], [sin(a)*cos(q0_PC(t)), -sin(q0_PC(t)), cos(a)*cos(q0_PC(t))]]) The angular velocity of the block can be computed with respect to the ground. >>> block.frame.ang_vel_in(ground.frame) u0_PC(t)*A.x The position of the block's center of mass can be found with: >>> block.masscenter.pos_from(ground.masscenter) d*G_frame.x + h*B_frame.x + q1_PC(t)*A.y + q2_PC(t)*A.z Finally, the linear velocity of the block's center of mass can be computed with respect to the ground. >>> block.masscenter.vel(ground.frame) u1_PC(t)*A.y + u2_PC(t)*A.z In some cases it could be your preference to only define the normals of the plane with respect to both bodies. This can most easily be done by supplying vectors to the ``interframe`` arguments. What will happen in this case is that an interframe will be created with its ``x`` axis aligned with the provided vector. For a further explanation of how this is done see the notes of the ``Joint`` class. In the code below, the above example (with the block on the slope) is recreated by supplying vectors to the interframe arguments. Note that the previously described option is however more computationally efficient, because the algorithm now has to compute the rotation angle between the provided vector and the 'x' axis. >>> from sympy import symbols, cos, sin >>> from sympy.physics.mechanics import PlanarJoint, RigidBody >>> a, d, h = symbols('a d h') >>> ground = RigidBody('G') >>> block = RigidBody('B') >>> joint = PlanarJoint( ... 'PC', ground, block, parent_point=d * ground.x, ... child_point=-h * block.x, child_interframe=block.x, ... parent_interframe=cos(a) * ground.x + sin(a) * ground.z) >>> block.frame.dcm(ground.frame).simplify() Matrix([ [ cos(a), 0, sin(a)], [-sin(a)*sin(q0_PC(t)), cos(q0_PC(t)), sin(q0_PC(t))*cos(a)], [-sin(a)*cos(q0_PC(t)), -sin(q0_PC(t)), cos(a)*cos(q0_PC(t))]]) c 6>XE4n Xg4n [TU]XX1c1M &&}55rOc|URUSSSSS9nURUSSSS5nURU5$)NrrrTrVrrW)rAr;r!rDs rLr8PlanarJoint._generate_speedssP33F1Iq#BF4H226!9aaH &&}55rOczURRURURUR5 grQ)rGrrFrrrRs rLr>PlanarJoint._orient_framess0 ))  " "D$6$6  $ $ &rOc~URRURURUR-5 grQ)rGrrFr!rrRs rLr?!PlanarJoint._set_angular_velocitys3 ))  " "   $"4"4 4 6rOcURRURURSURS-URSURS--5 URR UR S5 URR URS5 URR URURSURS-URSURS--5 URRRURURUR5 g)Nrr)rErrDrCrSrrFrGr*rDrCrrr,rRs rLr@ PlanarJoint._set_linear_velocitys,       # #A &)<)r?r@rrrs@rLrrfsPdAE9=DH:> <(##''""((DD6 6 & 6 = =rOrc\^\rSrSrSrS U4SjjrSrSrSrSr Sr S r S r U=r $) riaSpherical (Ball-and-Socket) Joint. .. image:: SphericalJoint.svg :align: center :width: 600 Explanation =========== A spherical joint is defined such that the child body is free to rotate in any direction, without allowing a translation of the ``child_point``. As can also be seen in the image, the ``parent_point`` and ``child_point`` are fixed on top of each other, i.e. the ``joint_point``. This rotation is defined using the :func:`parent_interframe.orient(child_interframe, rot_type, amounts, rot_order) ` method. The default rotation consists of three relative rotations, i.e. body-fixed rotations. Based on the direction cosine matrix following from these rotations, the angular velocity is computed based on the generalized coordinates and generalized speeds. Parameters ========== name : string A unique name for the joint. parent : Particle or RigidBody The parent body of joint. child : Particle or RigidBody The child body of joint. coordinates: iterable of dynamicsymbols, optional Generalized coordinates of the joint. speeds : iterable of dynamicsymbols, optional Generalized speeds of joint. parent_point : Point or Vector, optional Attachment point where the joint is fixed to the parent body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the parent's mass center. child_point : Point or Vector, optional Attachment point where the joint is fixed to the child body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the child's mass center. parent_interframe : ReferenceFrame, optional Intermediate frame of the parent body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the parent's own frame. child_interframe : ReferenceFrame, optional Intermediate frame of the child body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the child's own frame. rot_type : str, optional The method used to generate the direction cosine matrix. Supported methods are: - ``'Body'``: three successive rotations about new intermediate axes, also called "Euler and Tait-Bryan angles" - ``'Space'``: three successive rotations about the parent frames' unit vectors The default method is ``'Body'``. amounts : Expressions defining the rotation angles or direction cosine matrix. These must match the ``rot_type``. See examples below for details. The input types are: - ``'Body'``: 3-tuple of expressions, symbols, or functions - ``'Space'``: 3-tuple of expressions, symbols, or functions The default amounts are the given ``coordinates``. rot_order : str or int, optional If applicable, the order of the successive of rotations. The string ``'123'`` and integer ``123`` are equivalent, for example. Required for ``'Body'`` and ``'Space'``. The default value is ``123``. Attributes ========== name : string The joint's name. parent : Particle or RigidBody The joint's parent body. child : Particle or RigidBody The joint's child body. coordinates : Matrix Matrix of the joint's generalized coordinates. speeds : Matrix Matrix of the joint's generalized speeds. parent_point : Point Attachment point where the joint is fixed to the parent body. child_point : Point Attachment point where the joint is fixed to the child body. parent_interframe : ReferenceFrame Intermediate frame of the parent body with respect to which the joint transformation is formulated. child_interframe : ReferenceFrame Intermediate frame of the child body with respect to which the joint transformation is formulated. kdes : Matrix Kinematical differential equations of the joint. Examples ========= A single spherical joint is created from two bodies and has the following basic attributes: >>> from sympy.physics.mechanics import RigidBody, SphericalJoint >>> parent = RigidBody('P') >>> parent P >>> child = RigidBody('C') >>> child C >>> joint = SphericalJoint('PC', parent, child) >>> joint SphericalJoint: PC parent: P child: C >>> joint.name 'PC' >>> joint.parent P >>> joint.child C >>> joint.parent_point P_masscenter >>> joint.child_point C_masscenter >>> joint.parent_interframe P_frame >>> joint.child_interframe C_frame >>> joint.coordinates Matrix([ [q0_PC(t)], [q1_PC(t)], [q2_PC(t)]]) >>> joint.speeds Matrix([ [u0_PC(t)], [u1_PC(t)], [u2_PC(t)]]) >>> child.frame.ang_vel_in(parent.frame).to_matrix(child.frame) Matrix([ [ u0_PC(t)*cos(q1_PC(t))*cos(q2_PC(t)) + u1_PC(t)*sin(q2_PC(t))], [-u0_PC(t)*sin(q2_PC(t))*cos(q1_PC(t)) + u1_PC(t)*cos(q2_PC(t))], [ u0_PC(t)*sin(q1_PC(t)) + u2_PC(t)]]) >>> child.frame.x.to_matrix(parent.frame) Matrix([ [ cos(q1_PC(t))*cos(q2_PC(t))], [sin(q0_PC(t))*sin(q1_PC(t))*cos(q2_PC(t)) + sin(q2_PC(t))*cos(q0_PC(t))], [sin(q0_PC(t))*sin(q2_PC(t)) - sin(q1_PC(t))*cos(q0_PC(t))*cos(q2_PC(t))]]) >>> joint.child_point.pos_from(joint.parent_point) 0 To further demonstrate the use of the spherical joint, the kinematics of a spherical joint with a ZXZ rotation can be created as follows. >>> from sympy import symbols >>> from sympy.physics.mechanics import RigidBody, SphericalJoint >>> l1 = symbols('l1') First create bodies to represent the fixed floor and a pendulum bob. >>> floor = RigidBody('F') >>> bob = RigidBody('B') The joint will connect the bob to the floor, with the joint located at a distance of ``l1`` from the child's center of mass and the rotation set to a body-fixed ZXZ rotation. >>> joint = SphericalJoint('S', floor, bob, child_point=l1 * bob.y, ... rot_type='body', rot_order='ZXZ') Now that the joint is established, the kinematics of the connected body can be accessed. The position of the bob's masscenter is found with: >>> bob.masscenter.pos_from(floor.masscenter) - l1*B_frame.y The angular velocities of the pendulum link can be computed with respect to the floor. >>> bob.frame.ang_vel_in(floor.frame).to_matrix( ... floor.frame).simplify() Matrix([ [u1_S(t)*cos(q0_S(t)) + u2_S(t)*sin(q0_S(t))*sin(q1_S(t))], [u1_S(t)*sin(q0_S(t)) - u2_S(t)*sin(q1_S(t))*cos(q0_S(t))], [ u0_S(t) + u2_S(t)*cos(q1_S(t))]]) Finally, the linear velocity of the bob's center of mass can be computed. >>> bob.masscenter.vel(floor.frame).to_matrix(bob.frame) Matrix([ [ l1*(u0_S(t)*cos(q1_S(t)) + u2_S(t))], [ 0], [-l1*(u0_S(t)*sin(q1_S(t))*sin(q2_S(t)) + u1_S(t)*cos(q2_S(t)))]]) c N>XlXlXl[T U]XX4UXgUU S9 gr) _rot_type_amounts _rot_orderrrM)rAr+rBrCr:r;rDrErFrGrot_typeamounts rot_orderrs rLrMSphericalJoint.__init__s5" # u6%+<*:  SphericalJoint._orient_framess/ >>   !)< <%!$..!1233F2GIJ J'+mm&;$"" $$T%;%;T^^%,oo ?rOc j[RnURRUR5R [ URUR5VVs0sHup#URU5U_M snn5nURRURU5 gs snnfrQ) r rrGrrFxreplacezipr:r;rr)rArrrvels rLr?$SphericalJoint._set_angular_velocitys   ##..t/E/EFOO&)$*:*:DKK&H I&HdaQVVAY\&H I  ))$*@*@#F Js"B/ crURRURS5 URRURS5 URRUR S5 UR RRURURUR 5 grrrRs rLr@#SphericalJoint._set_linear_velocitys   !2!2A6 !!$"4"4a8   !2!2A6 ))$*;*;T=O=O*.*;*; =rO)rerfrd) NNNNNNrsN{rrrrrrMrSr6r8r>r?r@rrrs@rLrrsDJVFJHLAE <(?N?G==rOrcX^\rSrSrSrS U4SjjrSrSrSrSr Sr S r S r U=r $) riaWeld Joint. .. raw:: html :file: ../../../doc/src/modules/physics/mechanics/api/WeldJoint.svg Explanation =========== A weld joint is defined such that there is no relative motion between the child and parent bodies. The direction cosine matrix between the attachment frame (``parent_interframe`` and ``child_interframe``) is the identity matrix and the attachment points (``parent_point`` and ``child_point``) are coincident. The page on the joints framework gives a more detailed explanation of the intermediate frames. Parameters ========== name : string A unique name for the joint. parent : Particle or RigidBody The parent body of joint. child : Particle or RigidBody The child body of joint. parent_point : Point or Vector, optional Attachment point where the joint is fixed to the parent body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the parent's mass center. child_point : Point or Vector, optional Attachment point where the joint is fixed to the child body. If a vector is provided, then the attachment point is computed by adding the vector to the body's mass center. The default value is the child's mass center. parent_interframe : ReferenceFrame, optional Intermediate frame of the parent body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the parent's own frame. child_interframe : ReferenceFrame, optional Intermediate frame of the child body with respect to which the joint transformation is formulated. If a Vector is provided then an interframe is created which aligns its X axis with the given vector. The default value is the child's own frame. Attributes ========== name : string The joint's name. parent : Particle or RigidBody The joint's parent body. child : Particle or RigidBody The joint's child body. coordinates : Matrix Matrix of the joint's generalized coordinates. The default value is ``dynamicsymbols(f'q_{joint.name}')``. speeds : Matrix Matrix of the joint's generalized speeds. The default value is ``dynamicsymbols(f'u_{joint.name}')``. parent_point : Point Attachment point where the joint is fixed to the parent body. child_point : Point Attachment point where the joint is fixed to the child body. parent_interframe : ReferenceFrame Intermediate frame of the parent body with respect to which the joint transformation is formulated. child_interframe : ReferenceFrame Intermediate frame of the child body with respect to which the joint transformation is formulated. kdes : Matrix Kinematical differential equations of the joint. Examples ========= A single weld joint is created from two bodies and has the following basic attributes: >>> from sympy.physics.mechanics import RigidBody, WeldJoint >>> parent = RigidBody('P') >>> parent P >>> child = RigidBody('C') >>> child C >>> joint = WeldJoint('PC', parent, child) >>> joint WeldJoint: PC parent: P child: C >>> joint.name 'PC' >>> joint.parent P >>> joint.child C >>> joint.parent_point P_masscenter >>> joint.child_point C_masscenter >>> joint.coordinates Matrix(0, 0, []) >>> joint.speeds Matrix(0, 0, []) >>> child.frame.ang_vel_in(parent.frame) 0 >>> child.frame.dcm(parent.frame) Matrix([ [1, 0, 0], [0, 1, 0], [0, 0, 1]]) >>> joint.child_point.pos_from(joint.parent_point) 0 To further demonstrate the use of the weld joint, two relatively-fixed bodies rotated by a quarter turn about the Y axis can be created as follows: >>> from sympy import symbols, pi >>> from sympy.physics.mechanics import ReferenceFrame, RigidBody, WeldJoint >>> l1, l2 = symbols('l1 l2') First create the bodies to represent the parent and rotated child body. >>> parent = RigidBody('P') >>> child = RigidBody('C') Next the intermediate frame specifying the fixed rotation with respect to the parent can be created. >>> rotated_frame = ReferenceFrame('Pr') >>> rotated_frame.orient_axis(parent.frame, parent.y, pi / 2) The weld between the parent body and child body is located at a distance ``l1`` from the parent's center of mass in the X direction and ``l2`` from the child's center of mass in the child's negative X direction. >>> weld = WeldJoint('weld', parent, child, parent_point=l1 * parent.x, ... child_point=-l2 * child.x, ... parent_interframe=rotated_frame) Now that the joint has been established, the kinematics of the bodies can be accessed. The direction cosine matrix of the child body with respect to the parent can be found: >>> child.frame.dcm(parent.frame) Matrix([ [0, 0, -1], [0, 1, 0], [1, 0, 0]]) As can also been seen from the direction cosine matrix, the parent X axis is aligned with the child's Z axis: >>> parent.x == child.z True The position of the child's center of mass with respect to the parent's center of mass can be found with: >>> child.masscenter.pos_from(parent.masscenter) l1*P_frame.x + l2*C_frame.x The angular velocity of the child with respect to the parent is 0 as one would expect. >>> child.frame.ang_vel_in(parent.frame) 0 c d>[TU]XU//UXVUS9 [SS/5RUlg)Nrrr)rrMrTr=) rAr+rBrCrDrErFrGrs rLrMWeldJoint.__init__ps= ub"l$*:  <Aq"%'' rOcTSURSURSUR3$)Nz WeldJoint: rrrrRs rLrSWeldJoint.__str__ws0dii[ 4;;-@**' (rOc[5$rQrrs rLr6WeldJoint._generate_coordinates{ xrOc[5$rQrrs rLr8WeldJoint._generate_speeds~rrOczURRURURRS5 gr)rGrrFrrRs rLr>WeldJoint._orient_framess0 ))$*@*@*.*@*@*B*BA GrOcPURRURS5 grrrRs rLr?WeldJoint._set_angular_velocityrrOcHURRURS5 URRURS5 URRUR S5 UR RRURS5 gr)rErrDrr*r,rCrrRs rLr@WeldJoint._set_linear_velocitysv   !2!2A6 !!$"4"4a8   !2!2A6 %%d&8&8!fPLP:>((GE==rOrN)abcrrsympyrrrsympy.core.functionr!sympy.physics.mechanics.body_baser !sympy.physics.mechanics.functionsr sympy.physics.vectorr r r rrsympy.utilities.iterablesrsympy.utilities.exceptionsr__all__rrrrrrrrvrOrLrs$((,6C22.@ 9W-CW-tGQuGQTDQUDQNfAufAR c=%c=L x=Ux=vE=E=rO