\hSSKJrJrJrJrJrJrJrJr J r SSK J r SSK Jr SSKJrJr SSKJr SSKJr SS/r"S S\ 5r"S S5rS rg ) ) diffexpandsincossympifyeyezerosImmutableMatrix MatrixBase)Symbol)trigsimp)Vector _check_vector) translate)warn CoordinateSymReferenceFramecT^\rSrSrSrU4SjrSr\S5rSr Sr Sr S r U=r $) r a> A coordinate symbol/base scalar associated wrt a Reference Frame. Ideally, users should not instantiate this class. Instances of this class must only be accessed through the corresponding frame as 'frame[index]'. CoordinateSyms having the same frame and index parameters are equal (even though they may be instantiated separately). Parameters ========== name : string The display name of the CoordinateSym frame : ReferenceFrame The reference frame this base scalar belongs to index : 0, 1 or 2 The index of the dimension denoted by this coordinate variable Examples ======== >>> from sympy.physics.vector import ReferenceFrame, CoordinateSym >>> A = ReferenceFrame('A') >>> A[1] A_y >>> type(A[0]) >>> a_y = CoordinateSym('a_y', A, 1) >>> a_y == A[1] True c>0n[TU]X@5 [TU]"X40UD6n[U5 U[ SS5;a [ S5eX#4UlU$)NrzInvalid index specified)super _sanitize__xnew__ _check_framerange ValueError_id)clsnameframeindex assumptionsobj __class__s R/var/www/auris/envauris/lib/python3.13/site-packages/sympy/physics/vector/frame.py__new__CoordinateSym.__new__3s[  ++gs8K8U a #67 7. c:UR/URQ704$N)r rselfs r&__getnewargs_ex__CoordinateSym.__getnewargs_ex__?s %DHH%r))r)c URS$)Nr)rr,s r&r!CoordinateSym.frameBsxx{r)cd[U[5(aURUR:Xagg)NTF) isinstancerrr-others r&__eq__CoordinateSym.__eq__Fs' e] + +yyDHH$r)c X:X+$r+r4s r&__ne__CoordinateSym.__ne__Ns   r)cvURSR5URS4R5$)Nr)r__hash__r,s r&r>CoordinateSym.__hash__Qs/ $$& 4==??r)r9)__name__ __module__ __qualname____firstlineno____doc__r'r.propertyr!r6r:r>__static_attributes__ __classcell__)r%s@r&rr s=#J *!@@r)c\rSrSrSrSrS+SjrSrSrSr \ r S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrS,SjrS-SjrSrSr\S5r\S5r \S5r!\S5r"\S 5r#\S!5r$\S"5r%\S#5r&\S$5r'\S%5r(\S&5r)\S'5r*\S(5r+S)r,S*r-g).rUaA reference frame in classical mechanics. ReferenceFrame is a class used to represent a reference frame in classical mechanics. It has a standard basis of three unit vectors in the frame's x, y, and z directions. It also can have a rotation relative to a parent frame; this rotation is defined by a direction cosine matrix relating this frame's basis vectors to the parent frame's basis vectors. It can also have an angular velocity vector, defined in another frame. rNc[U[5(d [S5eUGbE[U[[45(d [S5e[ U5S:wa [ S5eUH#n[U[5(aM[S5e US-US-S -US-US -S -US-US -S -/UlUR5S -US-UR5S -US -UR5S -US -/Ul S UR5<SUS<S3S UR5<SUS <S3S UR5<SUS <S3/Ul X l OUS-US-US-/UlUR5S-UR5S-UR5S-/Ul SUR5-SUR5-SUR5-/Ul /SQUl Ubo[U[[45(d [S5e[ U5S:wa [ S5eUH#n[U[5(aM[S5e X0l Xl 0Ul 0Ul0Ul0Ul0UlURUR UR"/UlSUl[)[+/SQ5U4/5Ul[)[+/SQ5U4/5Ul[)[+/SQ5U4/5UlUbj[U[[45(d [S5e[ U5S:wa [ S5eUH#n[U[5(aM[S 5e OUS-US-US-/n[3USUS5[3US US 5[3US US 54Ul[6=R8S - sl[6R8Ulg)!arReferenceFrame initialization method. A ReferenceFrame has a set of orthonormal basis vectors, along with orientations relative to other ReferenceFrames and angular velocities relative to other ReferenceFrames. Parameters ========== indices : tuple of str Enables the reference frame's basis unit vectors to be accessed by Python's square bracket indexing notation using the provided three indice strings and alters the printing of the unit vectors to reflect this choice. latexs : tuple of str Alters the LaTeX printing of the reference frame's basis unit vectors to the provided three valid LaTeX strings. Examples ======== >>> from sympy.physics.vector import ReferenceFrame, vlatex >>> N = ReferenceFrame('N') >>> N.x N.x >>> O = ReferenceFrame('O', indices=('1', '2', '3')) >>> O.x O['1'] >>> O['1'] O['1'] >>> P = ReferenceFrame('P', latexs=('A1', 'A2', 'A3')) >>> vlatex(P.x) 'A1' ``symbols()`` can be used to create multiple Reference Frames in one step, for example: >>> from sympy.physics.vector import ReferenceFrame >>> from sympy import symbols >>> A, B, C = symbols('A B C', cls=ReferenceFrame) >>> D, E = symbols('D E', cls=ReferenceFrame, indices=('1', '2', '3')) >>> A[0] A_x >>> D.x D['1'] >>> E.y E['2'] >>> type(A) == type(D) True Unit dyads for the ReferenceFrame can be accessed through the attributes ``xx``, ``xy``, etc. For example: >>> from sympy.physics.vector import ReferenceFrame >>> N = ReferenceFrame('N') >>> N.yz (N.y|N.z) >>> N.zx (N.z|N.x) >>> P = ReferenceFrame('P', indices=['1', '2', '3']) >>> P.xx (P['1']|P['1']) >>> P.zy (P['3']|P['2']) Unit dyadic is also accessible via the ``u`` attribute: >>> from sympy.physics.vector import ReferenceFrame >>> N = ReferenceFrame('N') >>> N.u (N.x|N.x) + (N.y|N.y) + (N.z|N.z) >>> P = ReferenceFrame('P', indices=['1', '2', '3']) >>> P.u (P['1']|P['1']) + (P['2']|P['2']) + (P['3']|P['3']) zNeed to supply a valid nameNzSupply the indices as a listrzSupply 3 indiceszIndices must be stringsz['rz']r=_z \mathbf{\hat{z}_{z}}z.xz.yz.z_x_y_zz\mathbf{\hat{%s}_x}z\mathbf{\hat{%s}_y}z\mathbf{\hat{%s}_z})xyzzLatex entries must be stringsr=rrrr=rrrr=z)Supply the variable names as a list/tuplezSupply 3 variable nameszVariable names must be strings)r3str TypeErrortuplelistlenrstr_vecslower pretty_vecs latex_vecsindicesr _var_dict _dcm_dict _dcm_cache _ang_vel_dict _ang_acc_dict_dlist_currMatrixrMrNrOrvarlistr_countr")r-r r_latexs variablesis r&__init__ReferenceFrame.__init__dsZ$$$9: :  gt}55 >??7|q  !344!!S))#$=>>#UlWQZ7%?"UlWQZ7%?"UlWQZ7%?BDM"&!3gaj!@!%!3gaj!@!%!3gaj!@ CD >BZZ\=DQZ!I=AZZ\=DQZ!I=AZZ\=DQZ!I KDO #L#TkTD[D4KIDM $ t 3 $ t 3 $ t 3 5D !7 E 6 E 6 EHDO+DL  fudm44 >??6{a !344!!S))#$CDD%O  ~~t'9'94;M;MN  6),d3456),d3456),d345  i%77 KLL9~" !:;;!!S))#$DEEdTk4$;?I%ilD!<%ilD!<%ilD!<>  "#** r)c<[U[5(d US:aURU$[S5eURSU:Xa UR $URSU:Xa UR $URSU:Xa UR$[S5e)z Returns basis vector for the provided index, if the index is a string. If the index is a number, returns the coordinate variable correspon- -ding to that index. rzInvalid index providedrr=rKzNot a defined index)r3rVrhrr_rPrQrR)r-inds r& __getitem__ReferenceFrame.__getitem__s#s##Qw||C(( !9:: <<?c !66M <<?c !66M <<?c !66M23 3r)cZ[URURUR/5$r+)iterrPrQrRr,s r&__iter__ReferenceFrame.__iter__s TVVTVVTVV,--r)cUR$)zReturns the name of the frame. )r r,s r&__str__ReferenceFrame.__str__s yyr)c<SSSS.nX#R5;a [S5eU//n//nXE:wamUR5nUHPnUSRUR5nUH'nX;dM Xh/-n X;dMUR U 5 M) MR XE:waMmUHn U SU:wdMUR U 5 M! UR [S9 [U5S:waUS$S n [U RX2URUR55e) aReturns an inclusive list of reference frames that connect this reference frame to the provided reference frame. Parameters ========== other : ReferenceFrame The other reference frame to look for a connecting relationship to. num : integer ``0``, ``1``, and ``2`` will look for orientation, angular velocity, and angular acceleration relationships between the two frames, respectively. Returns ======= list Inclusive list of reference frames that connect this reference frame to the other reference frame. Examples ======== >>> from sympy.physics.vector import ReferenceFrame >>> A = ReferenceFrame('A') >>> B = ReferenceFrame('B') >>> C = ReferenceFrame('C') >>> D = ReferenceFrame('D') >>> B.orient_axis(A, A.x, 1.0) >>> C.orient_axis(B, B.x, 1.0) >>> D.orient_axis(C, C.x, 1.0) >>> D._dict_list(A, 0) [D, C, B, A] Raises ====== ValueError When no path is found between the two reference frames or ``num`` is an incorrect value. orientationzangular velocityzangular acceleration)rr=rKz$Valid values for num are 0, 1, or 2.)keyrz.No connecting {} path found between {} and {}.) keysrcopyreappendremovesortrZformatr ) r-r5num connect_typepossible_connecting_pathsoldlist frame_listframes_adjacent_to_lastadjacent_frameconnecting_pathmsgs r& _dict_listReferenceFrame._dict_lists1T)-13  '') )CD D&*VH!$'2/446G7 *4R.*?*?*D*I*I*K'&=N%7*47G*G*K5<<_M '>8(2 'Or"e+)00A ' "&&3&/ ( )Q .,Q/ />L$5tyy%**MNNr)c8SSKJn URU5nURUR5nXCR -n[ [US5SS9n[ [US5SS9n[ [US5SS9n[[XgU/5U4/5$)z4Angular velocity from time differentiating the DCM. rdynamicsymbolsT) recursiverKr) sympy.physics.vector.functionsrdcmr_tTr rrrg) r- otherframerdcm2diffdiffed angvelmatw1w2w3s r& _w_diff_dcmReferenceFrame._w_diff_dcmesA>>$'~001ZZ' fYq\*d ; fYq\*d ; fYq\*d ;|,j9:;;r)c[U5 U[R4UR;aURU[R4$UR U5[ UR 5-n0n[U5HJupE[R(a[X$SS9X0R U'M7X$X0R U'ML X0RU[R4'U$)a Returns a dictionary which expresses the coordinate variables of this frame in terms of the variables of otherframe. If Vector.simp is True, returns a simplified version of the mapped values. Else, returns them without simplification. Simplification of the expressions may take time. Parameters ========== otherframe : ReferenceFrame The other frame to map the variables to Examples ======== >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols >>> A = ReferenceFrame('A') >>> q = dynamicsymbols('q') >>> B = A.orientnew('B', 'Axis', [q, A.z]) >>> A.variable_map(B) {A_x: B_x*cos(q(t)) - B_y*sin(q(t)), A_y: B_x*sin(q(t)) + B_y*cos(q(t)), A_z: B_z} fu)method) rrsimpr`rrgrh enumerater )r-r vars_matrixmappingrlrPs r& variable_mapReferenceFrame.variable_mapps8 Z  $ 6>>:v{{";< <((:. 8J8J1KKKG!$;;/7 ?C0EGLLO,0;~GLLO, ( 9@NNJ 4 5Nr)c[U5 XR;aURU$URU5RU5$)a Returns the angular acceleration Vector of the ReferenceFrame. Effectively returns the Vector: ``N_alpha_B`` which represent the angular acceleration of B in N, where B is self, and N is otherframe. Parameters ========== otherframe : ReferenceFrame The ReferenceFrame which the angular acceleration is returned in. Examples ======== >>> from sympy.physics.vector import ReferenceFrame >>> N = ReferenceFrame('N') >>> A = ReferenceFrame('A') >>> V = 10 * N.x >>> A.set_ang_acc(N, V) >>> A.ang_acc_in(N) 10*N.x )rrd ang_vel_indt)r-rs r& ang_acc_inReferenceFrame.ang_acc_insC: Z ++ +%%j1 1??:.11*= =r)c[U5 URUS5n[S5n[[ U5S- 5HnX2UR X$S-- nM U$)aReturns the angular velocity Vector of the ReferenceFrame. Effectively returns the Vector: ^N omega ^B which represent the angular velocity of B in N, where B is self, and N is otherframe. Parameters ========== otherframe : ReferenceFrame The ReferenceFrame which the angular velocity is returned in. Examples ======== >>> from sympy.physics.vector import ReferenceFrame >>> N = ReferenceFrame('N') >>> A = ReferenceFrame('A') >>> V = 10 * N.x >>> A.set_ang_vel(N, V) >>> A.ang_vel_in(N) 10*N.x r=r)rrrrrZrc)r-rflistoutvecrls r&rReferenceFrame.ang_vel_ins^: Z  A.s5zA~&A Ah,,Uq5\: :F' r)cN[U5 XR;aURU$URUS5n[S5n[ [ U5S- 5HnX2UR X$S--nM X0RU'URURU'U$)aReturns the direction cosine matrix of this reference frame relative to the provided reference frame. The returned matrix can be used to express the orthogonal unit vectors of this frame in terms of the orthogonal unit vectors of ``otherframe``. Parameters ========== otherframe : ReferenceFrame The reference frame which the direction cosine matrix of this frame is formed relative to. Examples ======== The following example rotates the reference frame A relative to N by a simple rotation and then calculates the direction cosine matrix of N relative to A. >>> from sympy import symbols, sin, cos >>> from sympy.physics.vector import ReferenceFrame >>> q1 = symbols('q1') >>> N = ReferenceFrame('N') >>> A = ReferenceFrame('A') >>> A.orient_axis(N, q1, N.x) >>> N.dcm(A) Matrix([ [1, 0, 0], [0, cos(q1), -sin(q1)], [0, sin(q1), cos(q1)]]) The second row of the above direction cosine matrix represents the ``N.y`` unit vector in N expressed in A. Like so: >>> Ny = 0*A.x + cos(q1)*A.y - sin(q1)*A.z Thus, expressing ``N.y`` in A should return the same result: >>> N.y.express(A) cos(q1)*A.y - sin(q1)*A.z Notes ===== It is important to know what form of the direction cosine matrix is returned. If ``B.dcm(A)`` is called, it means the "direction cosine matrix of B rotated relative to A". This is the matrix :math:`{}^B\mathbf{C}^A` shown in the following relationship: .. math:: \begin{bmatrix} \hat{\mathbf{b}}_1 \\ \hat{\mathbf{b}}_2 \\ \hat{\mathbf{b}}_3 \end{bmatrix} = {}^B\mathbf{C}^A \begin{bmatrix} \hat{\mathbf{a}}_1 \\ \hat{\mathbf{a}}_2 \\ \hat{\mathbf{a}}_3 \end{bmatrix}. :math:`{}^B\mathbf{C}^A` is the matrix that expresses the B unit vectors in terms of the A unit vectors. rrr=)rrbrrrrZrar)r-rroutdcmrls r&rReferenceFrame.dcmsP Z  (??:. . A.Qs5zA~&AAh001u>>F''- #&,hh d# r)cbURR5n/n/nX;alUHnX`R;aXF/- nXV/- nM UHnURU M UHnURU M 0=UlURS'0UlO/n[ U5nSn U(aU (aUR S5n X;aYUR U 5 U RR5n U H(n X:Xa[S5 Sn OUR U 5 M* U(a U (aMURRXR05 URRX05 URRXR05 URRX05 g)NrTzxLoops are defined among the orientation of frames. This is likely not desired and may cause errors in your calculations.F) rbr~rarerYpoprrupdater) r-parent parent_orientframes dcm_dict_del dcm_cache_delr!visitedqueuecontnode neighborsneighbors r&_dcmReferenceFrame._dcm8s%%'   NN* G+L(  &OOD)&&$$T*'/1 0DNT[[^ DOGLEDDyy|&NN4( $ 3 3 5I$-#- "FG$)D! X.%. DD v78 56 89  $!67r)cBSSKJn [U5 [U[5(d[U[5(aX2p2[ U5n[ U5nURU5S:Xd [S5eURU5R5nURSSn[S5XwR-- [U5-[SUS*US/USSUS*/US*USS//5[!U5--XwR--nUR#X5 UR%UR&5n XRU5R5-n UR(R+X05 UR(R+X *05 0Ulg)aSets the orientation of this reference frame with respect to a parent reference frame by rotating through an angle about an axis fixed in the parent reference frame. Parameters ========== parent : ReferenceFrame Reference frame that this reference frame will be rotated relative to. axis : Vector Vector fixed in the parent frame about about which this frame is rotated. It need not be a unit vector and the rotation follows the right hand rule. angle : sympifiable Angle in radians by which it the frame is to be rotated. Warns ====== UserWarning If the orientation creates a kinematic loop. Examples ======== Setup variables for the examples: >>> from sympy import symbols >>> from sympy.physics.vector import ReferenceFrame >>> q1 = symbols('q1') >>> N = ReferenceFrame('N') >>> B = ReferenceFrame('B') >>> B.orient_axis(N, N.x, q1) The ``orient_axis()`` method generates a direction cosine matrix and its transpose which defines the orientation of B relative to N and vice versa. Once orient is called, ``dcm()`` outputs the appropriate direction cosine matrix: >>> B.dcm(N) Matrix([ [1, 0, 0], [0, cos(q1), sin(q1)], [0, -sin(q1), cos(q1)]]) >>> N.dcm(B) Matrix([ [1, 0, 0], [0, cos(q1), -sin(q1)], [0, sin(q1), cos(q1)]]) The following two lines show that the sense of the rotation can be defined by negating the vector direction or the angle. Both lines produce the same result. >>> B.orient_axis(N, -N.x, q1) >>> B.orient_axis(N, N.x, -q1) rrzAxis cannot be time-varying.rrKr=N)rrrr3rrrrrexpress normalizeargsrrrrgrrrrrcrr`) r-raxisanglertheta unit_axisunit_colparent_orient_axisthetadwvecs r& orient_axisReferenceFrame.orient_axismsz BV$''Juf,E,E%T"wwv!#;< <LL(224 >>!$Q' Vh+ +s5z 9 Q! hqk2a[!hqk\2qk\8A;24 5 J  "JJ.  /  &-n//0ll6*4466 !!6.1##T5M2r)c[U5 [U[5(d [S5eUR XR 5 g)a'Sets the orientation of this reference frame relative to another (parent) reference frame using a direction cosine matrix that describes the rotation from the parent to the child. Parameters ========== parent : ReferenceFrame Reference frame that this reference frame will be rotated relative to. dcm : Matrix, shape(3, 3) Direction cosine matrix that specifies the relative rotation between the two reference frames. Warns ====== UserWarning If the orientation creates a kinematic loop. Examples ======== Setup variables for the examples: >>> from sympy import symbols, Matrix, sin, cos >>> from sympy.physics.vector import ReferenceFrame >>> q1 = symbols('q1') >>> A = ReferenceFrame('A') >>> B = ReferenceFrame('B') >>> N = ReferenceFrame('N') A simple rotation of ``A`` relative to ``N`` about ``N.x`` is defined by the following direction cosine matrix: >>> dcm = Matrix([[1, 0, 0], ... [0, cos(q1), -sin(q1)], ... [0, sin(q1), cos(q1)]]) >>> A.orient_explicit(N, dcm) >>> A.dcm(N) Matrix([ [1, 0, 0], [0, cos(q1), sin(q1)], [0, -sin(q1), cos(q1)]]) This is equivalent to using ``orient_axis()``: >>> B.orient_axis(N, N.x, q1) >>> B.dcm(N) Matrix([ [1, 0, 0], [0, cos(q1), sin(q1)], [0, -sin(q1), cos(q1)]]) **Note carefully that** ``N.dcm(B)`` **(the transpose) would be passed into** ``orient_explicit()`` **for** ``A.dcm(N)`` **to match** ``B.dcm(N)``: >>> A.orient_explicit(N, N.dcm(B)) >>> A.dcm(N) Matrix([ [1, 0, 0], [0, cos(q1), sin(q1)], [0, -sin(q1), cos(q1)]]) +Amounts must be a SymPy Matrix type object.N)rr3r rW orient_dcmr)r-rrs r&orient_explicitReferenceFrame.orient_explicits8D V#z**IJ J &r)c2[U5 [U[5(d [S5eUR XR 5 UR U5nURRX05 URRX*05 0Ul g)a Sets the orientation of this reference frame relative to another (parent) reference frame using a direction cosine matrix that describes the rotation from the child to the parent. Parameters ========== parent : ReferenceFrame Reference frame that this reference frame will be rotated relative to. dcm : Matrix, shape(3, 3) Direction cosine matrix that specifies the relative rotation between the two reference frames. Warns ====== UserWarning If the orientation creates a kinematic loop. Examples ======== Setup variables for the examples: >>> from sympy import symbols, Matrix, sin, cos >>> from sympy.physics.vector import ReferenceFrame >>> q1 = symbols('q1') >>> A = ReferenceFrame('A') >>> B = ReferenceFrame('B') >>> N = ReferenceFrame('N') A simple rotation of ``A`` relative to ``N`` about ``N.x`` is defined by the following direction cosine matrix: >>> dcm = Matrix([[1, 0, 0], ... [0, cos(q1), sin(q1)], ... [0, -sin(q1), cos(q1)]]) >>> A.orient_dcm(N, dcm) >>> A.dcm(N) Matrix([ [1, 0, 0], [0, cos(q1), sin(q1)], [0, -sin(q1), cos(q1)]]) This is equivalent to using ``orient_axis()``: >>> B.orient_axis(N, N.x, q1) >>> B.dcm(N) Matrix([ [1, 0, 0], [0, cos(q1), sin(q1)], [0, -sin(q1), cos(q1)]]) rN) rr3r rWrrrrcrr`)r-rrrs r&rReferenceFrame.orient_dcms}p V#z**IJ J &%% ' !!6.1##T5M2r)c US:Xa;[/SQS[U5[U5*/S[U5[U5//5$US:Xa;[[U5S[U5//SQ[U5*S[U5//5$US:Xa;[[U5[U5*S/[U5[U5S//SQ/5$g) z'DCM for simple axis 1,2,or 3 rotations.r=rSrrKrTrrUN)rgrr)r-rrs r&_rotReferenceFrame._rotUs 199s5zCJ;7s5z3u:689 9QYCJ3u:6$ ZKCJ79: :QYCJU Q7JE A6$&' 'r)c[U5n[U5H)upE[U[5(aM[ U5X4'M+ Sn[ [ U5SS5nXv;a [S5eUVs/sHn[U5PM nn[U5S[U5-s=:XaS:Xd O [S5e[Xs5V V s/sHupURX5PM n n n X7U 4$s snfs sn n f)aHelper for orient_body_fixed and orient_space_fixed. Parameters ========== angles : 3-tuple of sympifiable Three angles in radians used for the successive rotations. rotation_order : 3 character string or 3 digit integer Order of the rotations. The order can be specified by the strings ``'XZX'``, ``'131'``, or the integer ``131``. There are 12 unique valid rotation orders. Returns ======= amounts : list List of sympifiables corresponding to the rotation angles. rot_order : list List of integers corresponding to the axis of rotation. rot_matrices : list List of DCM around the given axis with corresponding magnitude. 123231312132213321121131212232313323XYZxyz123123z(The rotation order is not a valid order.rz*Body orientation takes 3 values & 3 orders) rYrr3rrrrVrWintrZzipr) r-anglesrotation_orderamountsrlvapproved_orders rot_orderrorderamount rot_matricess r&_parse_consecutive_rotations+ReferenceFrame._parse_consecutive_rotationsds.v,g&DAa(($QZ 'Bc.18XF  +FG G%./YSVY /G C N 27a7HI I/29/FH/FOU %0/F H<// 0Hs 0C(C-cSSKJn [U5 URX#5upVnUR XSUS-US-5 [ S5Vs/sHn[ SS5PM n n[U5H*upXZRUR5XU S- 'M, U SUSRU SUSRU S----upnXR-XR--XR--nURRX05 URRX*05 0Ulgs snf)a, Rotates this reference frame relative to the parent reference frame by right hand rotating through three successive body fixed simple axis rotations. Each subsequent axis of rotation is about the "body fixed" unit vectors of a new intermediate reference frame. This type of rotation is also referred to rotating through the `Euler and Tait-Bryan Angles`_. .. _Euler and Tait-Bryan Angles: https://en.wikipedia.org/wiki/Euler_angles The computed angular velocity in this method is by default expressed in the child's frame, so it is most preferable to use ``u1 * child.x + u2 * child.y + u3 * child.z`` as generalized speeds. Parameters ========== parent : ReferenceFrame Reference frame that this reference frame will be rotated relative to. angles : 3-tuple of sympifiable Three angles in radians used for the successive rotations. rotation_order : 3 character string or 3 digit integer Order of the rotations about each intermediate reference frames' unit vectors. The Euler rotation about the X, Z', X'' axes can be specified by the strings ``'XZX'``, ``'131'``, or the integer ``131``. There are 12 unique valid rotation orders (6 Euler and 6 Tait-Bryan): zxz, xyx, yzy, zyz, xzx, yxy, xyz, yzx, zxy, xzy, zyx, and yxz. Warns ====== UserWarning If the orientation creates a kinematic loop. Examples ======== Setup variables for the examples: >>> from sympy import symbols >>> from sympy.physics.vector import ReferenceFrame >>> q1, q2, q3 = symbols('q1, q2, q3') >>> N = ReferenceFrame('N') >>> B = ReferenceFrame('B') >>> B1 = ReferenceFrame('B1') >>> B2 = ReferenceFrame('B2') >>> B3 = ReferenceFrame('B3') For example, a classic Euler Angle rotation can be done by: >>> B.orient_body_fixed(N, (q1, q2, q3), 'XYX') >>> B.dcm(N) Matrix([ [ cos(q2), sin(q1)*sin(q2), -sin(q2)*cos(q1)], [sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3), sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)], [sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]]) This rotates reference frame B relative to reference frame N through ``q1`` about ``N.x``, then rotates B again through ``q2`` about ``B.y``, and finally through ``q3`` about ``B.x``. It is equivalent to three successive ``orient_axis()`` calls: >>> B1.orient_axis(N, N.x, q1) >>> B2.orient_axis(B1, B1.y, q2) >>> B3.orient_axis(B2, B2.x, q3) >>> B3.dcm(N) Matrix([ [ cos(q2), sin(q1)*sin(q2), -sin(q2)*cos(q1)], [sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3), sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)], [sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]]) Acceptable rotation orders are of length 3, expressed in as a string ``'XYZ'`` or ``'123'`` or integer ``123``. Rotations about an axis twice in a row are prohibited. >>> B.orient_body_fixed(N, (q1, q2, 0), 'ZXZ') >>> B.orient_body_fixed(N, (q1, q2, 0), '121') >>> B.orient_body_fixed(N, (q1, q2, q3), 123) rrr=rKrNrrrrrrr rrrrrPrQrRrcrr`r-rrrrrrrrLrot_vecsrlru1u2u3rs r&orient_body_fixed ReferenceFrame.orient_body_fixeds8d BV+/+L+L ,$(L &q/LO;l1oMN).q2AE!QK2!),HA%,Z__^5F5F%GHK "-a[<?#4#4 QK,q/++hqk9 9$;; FF{R&&[(2;6 !!6.1##T5M23EcSSKJn [U5 URX#5upVnUR XSUS-US-5 [ S5Vs/sHn[ SS5PM n n[U5H*upXZRUR5XU S- 'M, U SUSRU SUSRU S----upnXR-XR--XR--nURRX05 URRX*05 0Ulgs snf)a[ Rotates this reference frame relative to the parent reference frame by right hand rotating through three successive space fixed simple axis rotations. Each subsequent axis of rotation is about the "space fixed" unit vectors of the parent reference frame. The computed angular velocity in this method is by default expressed in the child's frame, so it is most preferable to use ``u1 * child.x + u2 * child.y + u3 * child.z`` as generalized speeds. Parameters ========== parent : ReferenceFrame Reference frame that this reference frame will be rotated relative to. angles : 3-tuple of sympifiable Three angles in radians used for the successive rotations. rotation_order : 3 character string or 3 digit integer Order of the rotations about the parent reference frame's unit vectors. The order can be specified by the strings ``'XZX'``, ``'131'``, or the integer ``131``. There are 12 unique valid rotation orders. Warns ====== UserWarning If the orientation creates a kinematic loop. Examples ======== Setup variables for the examples: >>> from sympy import symbols >>> from sympy.physics.vector import ReferenceFrame >>> q1, q2, q3 = symbols('q1, q2, q3') >>> N = ReferenceFrame('N') >>> B = ReferenceFrame('B') >>> B1 = ReferenceFrame('B1') >>> B2 = ReferenceFrame('B2') >>> B3 = ReferenceFrame('B3') >>> B.orient_space_fixed(N, (q1, q2, q3), '312') >>> B.dcm(N) Matrix([ [ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)], [-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)], [ sin(q3)*cos(q2), -sin(q2), cos(q2)*cos(q3)]]) is equivalent to: >>> B1.orient_axis(N, N.z, q1) >>> B2.orient_axis(B1, N.x, q2) >>> B3.orient_axis(B2, N.y, q3) >>> B3.dcm(N).simplify() Matrix([ [ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)], [-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)], [ sin(q3)*cos(q2), -sin(q2), cos(q2)*cos(q3)]]) It is worth noting that space-fixed and body-fixed rotations are related by the order of the rotations, i.e. the reverse order of body fixed will give space fixed and vice versa. >>> B.orient_space_fixed(N, (q1, q2, q3), '231') >>> B.dcm(N) Matrix([ [cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)], [ -sin(q2), cos(q2)*cos(q3), sin(q3)*cos(q2)], [sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]]) >>> B.orient_body_fixed(N, (q3, q2, q1), '132') >>> B.dcm(N) Matrix([ [cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)], [ -sin(q2), cos(q2)*cos(q3), sin(q3)*cos(q2)], [sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]]) rrrKr=rNrrs r&orient_space_fixed!ReferenceFrame.orient_space_fixeds8` BV+/+L+L ,$(L &q/LO;l1oMN).q2AE!QK2!),HA%,Z__^5F5F%GHK "-a[<?#4#4 QK,q/++hqk9 9$;; FF{R&&[(2;6 !!6.1##T5M23rc SSKJn [U5 [U5n[ U5H)upE[ U[ 5(aM[U5X$'M+ [ U[[45[U5S:H-(d [S5eUupgp[US-US--US-- U S-- SXx-Xi-- -SXh-Xy---/SXx-Xi---US-US-- US--U S-- SX-Xg-- -/SXy-Xh-- -SXg-X---US-US-- US-- U S--//5n URX5 URn Uupgp[Xk5n [X{5n [X5n[X5nSX-X--X-- X-- -nSX-X--X-- X-- -nSX-X--X-- X-- -n[ [UUU/5U4/5nURR!UU05 URR!UU*05 0Ulg)aSets the orientation of this reference frame relative to a parent reference frame via an orientation quaternion. An orientation quaternion is defined as a finite rotation a unit vector, ``(lambda_x, lambda_y, lambda_z)``, by an angle ``theta``. The orientation quaternion is described by four parameters: - ``q0 = cos(theta/2)`` - ``q1 = lambda_x*sin(theta/2)`` - ``q2 = lambda_y*sin(theta/2)`` - ``q3 = lambda_z*sin(theta/2)`` See `Quaternions and Spatial Rotation `_ on Wikipedia for more information. Parameters ========== parent : ReferenceFrame Reference frame that this reference frame will be rotated relative to. numbers : 4-tuple of sympifiable The four quaternion scalar numbers as defined above: ``q0``, ``q1``, ``q2``, ``q3``. Warns ====== UserWarning If the orientation creates a kinematic loop. Examples ======== Setup variables for the examples: >>> from sympy import symbols >>> from sympy.physics.vector import ReferenceFrame >>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3') >>> N = ReferenceFrame('N') >>> B = ReferenceFrame('B') Set the orientation: >>> B.orient_quaternion(N, (q0, q1, q2, q3)) >>> B.dcm(N) Matrix([ [q0**2 + q1**2 - q2**2 - q3**2, 2*q0*q3 + 2*q1*q2, -2*q0*q2 + 2*q1*q3], [ -2*q0*q3 + 2*q1*q2, q0**2 - q1**2 + q2**2 - q3**2, 2*q0*q1 + 2*q2*q3], [ 2*q0*q2 + 2*q1*q3, -2*q0*q1 + 2*q2*q3, q0**2 - q1**2 - q2**2 + q3**2]]) rrz'Amounts are a list or tuple of length 4rKN)rrrrYrr3rrrXrZrWrgrrrrcrr`)r-rnumbersrrlrq0q1q2q3parent_orient_quaterniontq0dq1dq2dq3drrrrs r&orient_quaternion ReferenceFrame.orient_quaternionTsbj BVw-g&DAa(($QZ '7T5M2c'la6GHEF F  RURU]RU*RU2"'BG+,"'BG+,."'BG+,URU]RU*RU2"'BG+,."'BG+,"'BG+,URU]RU*RU24 5 6 ! &3    2k2k2k2k #(SX%038; < #(SX%038; < #(SX%038; <B|,d345 !!64.1##TD5M2r)c[U5 Sn[[U5SS5nUR5nXE;a [ S5eUS:XaUR XSUS5 g US:XaUR X5 g US :XaURXU5 g US :XaURXU5 g US :XaURX5 g [S 5e)aSets the orientation of this reference frame relative to another (parent) reference frame. .. note:: It is now recommended to use the ``.orient_axis, .orient_body_fixed, .orient_space_fixed, .orient_quaternion`` methods for the different rotation types. Parameters ========== parent : ReferenceFrame Reference frame that this reference frame will be rotated relative to. rot_type : str The method used to generate the direction cosine matrix. Supported methods are: - ``'Axis'``: simple rotations about a single common axis - ``'DCM'``: for setting the direction cosine matrix directly - ``'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 - ``'Quaternion'``: rotations defined by four parameters which result in a singularity free direction cosine matrix 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: - ``'Axis'``: 2-tuple (expr/sym/func, Vector) - ``'DCM'``: Matrix, shape(3,3) - ``'Body'``: 3-tuple of expressions, symbols, or functions - ``'Space'``: 3-tuple of expressions, symbols, or functions - ``'Quaternion'``: 4-tuple of expressions, symbols, or functions 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'``. Warns ====== UserWarning If the orientation creates a kinematic loop. rrr*The supplied order is not an approved typeAXISr=rDCMBODYSPACE QUATERNION#That is not an implemented rotationN) rrrVupperrWrrrrrNotImplementedError)r-rrot_typerrrs r&orientReferenceFrame.orientsh VBc)nhA >>#  +HI I v    VQZ <     1    " "6I >   # #FY ?  %  " "6 3&&KL Lr)cURXXgS9nSn [[U5SS5nUR5nXI;a [ S5eUS:XaUR XSUS5 U$US :XaUR X5 U$US :XaURXU5 U$US :XaURXU5 U$US :XaURX5 U$[S 5e)a| Returns a new reference frame oriented with respect to this reference frame. See ``ReferenceFrame.orient()`` for detailed examples of how to orient reference frames. Parameters ========== newname : str Name for the new reference frame. rot_type : str The method used to generate the direction cosine matrix. Supported methods are: - ``'Axis'``: simple rotations about a single common axis - ``'DCM'``: for setting the direction cosine matrix directly - ``'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 - ``'Quaternion'``: rotations defined by four parameters which result in a singularity free direction cosine matrix 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: - ``'Axis'``: 2-tuple (expr/sym/func, Vector) - ``'DCM'``: Matrix, shape(3,3) - ``'Body'``: 3-tuple of expressions, symbols, or functions - ``'Space'``: 3-tuple of expressions, symbols, or functions - ``'Quaternion'``: 4-tuple of expressions, symbols, or functions 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'``. indices : tuple of str Enables the reference frame's basis unit vectors to be accessed by Python's square bracket indexing notation using the provided three indice strings and alters the printing of the unit vectors to reflect this choice. latexs : tuple of str Alters the LaTeX printing of the reference frame's basis unit vectors to the provided three valid LaTeX strings. Examples ======== >>> from sympy import symbols >>> from sympy.physics.vector import ReferenceFrame, vlatex >>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3') >>> N = ReferenceFrame('N') Create a new reference frame A rotated relative to N through a simple rotation. >>> A = N.orientnew('A', 'Axis', (q0, N.x)) Create a new reference frame B rotated relative to N through body-fixed rotations. >>> B = N.orientnew('B', 'Body', (q1, q2, q3), '123') Create a new reference frame C rotated relative to N through a simple rotation with unique indices and LaTeX printing. >>> C = N.orientnew('C', 'Axis', (q0, N.x), indices=('1', '2', '3'), ... latexs=(r'\hat{\mathbf{c}}_1',r'\hat{\mathbf{c}}_2', ... r'\hat{\mathbf{c}}_3')) >>> C['1'] C['1'] >>> print(vlatex(C['1'])) \hat{\mathbf{c}}_1 )rkr_rjrrrrrr=rrrrrr ) r%rrVr!rWrrrrrr") r-newnamer#rrrkr_rjnewframers r& orientnewReferenceFrame.orientnews d>>'*1"BBc)nhA >>#  +HI I v   qz71: >    $ $T 3   & &ti @  ' 'y A  %  & &t 5&&KL Lr)cUS:Xa [S5n[U5n[U5 URR X05 URR X*05 g)aDefine the angular acceleration Vector in a ReferenceFrame. Defines the angular acceleration of this ReferenceFrame, in another. Angular acceleration can be defined with respect to multiple different ReferenceFrames. Care must be taken to not create loops which are inconsistent. Parameters ========== otherframe : ReferenceFrame A ReferenceFrame to define the angular acceleration in value : Vector The Vector representing angular acceleration Examples ======== >>> from sympy.physics.vector import ReferenceFrame >>> N = ReferenceFrame('N') >>> A = ReferenceFrame('A') >>> V = 10 * N.x >>> A.set_ang_acc(N, V) >>> A.ang_acc_in(N) 10*N.x rN)rrrrdrr-rvalues r& set_ang_accReferenceFrame.set_ang_accpU: A:1IEe$Z  !!:"56  ''v7r)cUS:Xa [S5n[U5n[U5 URR X05 URR X*05 g)ayDefine the angular velocity vector in a ReferenceFrame. Defines the angular velocity of this ReferenceFrame, in another. Angular velocity can be defined with respect to multiple different ReferenceFrames. Care must be taken to not create loops which are inconsistent. Parameters ========== otherframe : ReferenceFrame A ReferenceFrame to define the angular velocity in value : Vector The Vector representing angular velocity Examples ======== >>> from sympy.physics.vector import ReferenceFrame >>> N = ReferenceFrame('N') >>> A = ReferenceFrame('A') >>> V = 10 * N.x >>> A.set_ang_vel(N, V) >>> A.ang_vel_in(N) 10*N.x rN)rrrrcrr,s r& set_ang_velReferenceFrame.set_ang_velr0r)cUR$)z=The basis Vector for the ReferenceFrame, in the x direction. )rMr,s r&rPReferenceFrame.x wwr)cUR$)z=The basis Vector for the ReferenceFrame, in the y direction. )rNr,s r&rQReferenceFrame.yr6r)cUR$)z=The basis Vector for the ReferenceFrame, in the z direction. )rOr,s r&rRReferenceFrame.zr6r)cX[R"URUR5$)z:Unit dyad of basis Vectors x and x for the ReferenceFrame.)routerrPr,s r&xxReferenceFrame.xx||DFFDFF++r)cX[R"URUR5$)z:Unit dyad of basis Vectors x and y for the ReferenceFrame.)rr<rPrQr,s r&xyReferenceFrame.xyr?r)cX[R"URUR5$)z:Unit dyad of basis Vectors x and z for the ReferenceFrame.)rr<rPrRr,s r&xzReferenceFrame.xzr?r)cX[R"URUR5$)z:Unit dyad of basis Vectors y and x for the ReferenceFrame.)rr<rQrPr,s r&yxReferenceFrame.yxr?r)cX[R"URUR5$)z:Unit dyad of basis Vectors y and y for the ReferenceFrame.)rr<rQr,s r&yyReferenceFrame.yyr?r)cX[R"URUR5$)z:Unit dyad of basis Vectors y and z for the ReferenceFrame.)rr<rQrRr,s r&yzReferenceFrame.yzr?r)cX[R"URUR5$)z:Unit dyad of basis Vectors z and x for the ReferenceFrame.)rr<rRrPr,s r&zxReferenceFrame.zxr?r)cX[R"URUR5$)z:Unit dyad of basis Vectors z and y for the ReferenceFrame.)rr<rRrQr,s r&zyReferenceFrame.zyr?r)cX[R"URUR5$)z:Unit dyad of basis Vectors z and z for the ReferenceFrame.)rr<rRr,s r&zzReferenceFrame.zzr?r)cNURUR-UR-$)z#Unit dyadic for the ReferenceFrame.)r=rJrVr,s r&uReferenceFrame.us ww 477**r)cSSKJn URU5nU"U/X!5Sn[U5S:XaUS$[ U5$)aReturns the partial angular velocities of this frame in the given frame with respect to one or more provided generalized speeds. Parameters ========== frame : ReferenceFrame The frame with which the angular velocity is defined in. gen_speeds : functions of time The generalized speeds. Returns ======= partial_velocities : tuple of Vector The partial angular velocity vectors corresponding to the provided generalized speeds. Examples ======== >>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols >>> N = ReferenceFrame('N') >>> A = ReferenceFrame('A') >>> u1, u2 = dynamicsymbols('u1, u2') >>> A.set_ang_vel(N, u1 * A.x + u2 * N.y) >>> A.partial_velocity(N, u1) A.x >>> A.partial_velocity(N, u1, u2) (A.x, N.y) r)partial_velocityr=)rr\rrZrX)r-r! gen_speedsr\velpartialss r&r\ReferenceFrame.partial_velocitysJ@ Dooe$#SE:=a@ x=A A; ? "r))rdrcrfrbrarer`rMrNrOr"r_r^r r]r[rh)NNN)r)rNNN).r@rArBrCrDrirmrqrurx__repr__rrrrrrrrrrrrrrrr$r)r.r2rErPrQrRr=rArDrGrJrMrPrSrVrYr\rFr9r)r&rrUs FY+v4*.HFOP <)V!>F"HTl38jWrH'TCJ '(0TbH`DZxNM`?A7;n`"8H"8H,,,,,,,,,,,,,,,,,,++(#r)c^SSKJn [U[5(dU"U[S55eg)Nr=)VectorTypeErrorA)vectorrcr3r)r5rcs r&rr$s)' e^ , ,e^C%899 -r)N)sympyrrrrrrr r rgr sympy.core.symbolr sympy.simplify.trigsimpr sympy.physics.vector.vectorrrsympy.utilities.miscrwarningsr__all__rrrr9r)r&rmsTGGG$,=* , -E@FE@PL#L#^.:r)