\hNSSKJrJrJrJrJr SSKJr SSKJ r J r SSK J r SSK JrJrJrJr SSKJr SSKJr S/r"S S\ 5rg ) )diffzerosMatrixeyesympify)default_sort_key)dynamicsymbolsReferenceFrame)_Methods)find_dynamicsymbolsmsubs_f_list_parser_validate_coordinates) Linearizer)iterableLagrangesMethodc\rSrSrSrSSjrSrSr\S5r \S5r \S 5r \S 5r SS jr SS jrSS jrSSjr\S5r\S5r\S5r\S5r\S5rSrg)r as Lagrange's method object. Explanation =========== This object generates the equations of motion in a two step procedure. The first step involves the initialization of LagrangesMethod by supplying the Lagrangian and the generalized coordinates, at the bare minimum. If there are any constraint equations, they can be supplied as keyword arguments. The Lagrange multipliers are automatically generated and are equal in number to the constraint equations. Similarly any non-conservative forces can be supplied in an iterable (as described below and also shown in the example) along with a ReferenceFrame. This is also discussed further in the __init__ method. Attributes ========== q, u : Matrix Matrices of the generalized coordinates and speeds loads : iterable Iterable of (Point, vector) or (ReferenceFrame, vector) tuples describing the forces on the system. bodies : iterable Iterable containing the rigid bodies and particles of the system. mass_matrix : Matrix The system's mass matrix forcing : Matrix The system's forcing vector mass_matrix_full : Matrix The "mass matrix" for the qdot's, qdoubledot's, and the lagrange multipliers (lam) forcing_full : Matrix The forcing vector for the qdot's, qdoubledot's and lagrange multipliers (lam) Examples ======== This is a simple example for a one degree of freedom translational spring-mass-damper. In this example, we first need to do the kinematics. This involves creating generalized coordinates and their derivatives. Then we create a point and set its velocity in a frame. >>> from sympy.physics.mechanics import LagrangesMethod, Lagrangian >>> from sympy.physics.mechanics import ReferenceFrame, Particle, Point >>> from sympy.physics.mechanics import dynamicsymbols >>> from sympy import symbols >>> q = dynamicsymbols('q') >>> qd = dynamicsymbols('q', 1) >>> m, k, b = symbols('m k b') >>> N = ReferenceFrame('N') >>> P = Point('P') >>> P.set_vel(N, qd * N.x) We need to then prepare the information as required by LagrangesMethod to generate equations of motion. First we create the Particle, which has a point attached to it. Following this the lagrangian is created from the kinetic and potential energies. Then, an iterable of nonconservative forces/torques must be constructed, where each item is a (Point, Vector) or (ReferenceFrame, Vector) tuple, with the Vectors representing the nonconservative forces or torques. >>> Pa = Particle('Pa', P, m) >>> Pa.potential_energy = k * q**2 / 2.0 >>> L = Lagrangian(N, Pa) >>> fl = [(P, -b * qd * N.x)] Finally we can generate the equations of motion. First we create the LagrangesMethod object. To do this one must supply the Lagrangian, and the generalized coordinates. The constraint equations, the forcelist, and the inertial frame may also be provided, if relevant. Next we generate Lagrange's equations of motion, such that: Lagrange's equations of motion = 0. We have the equations of motion at this point. >>> l = LagrangesMethod(L, [q], forcelist = fl, frame = N) >>> print(l.form_lagranges_equations()) Matrix([[b*Derivative(q(t), t) + 1.0*k*q(t) + m*Derivative(q(t), (t, 2))]]) We can also solve for the states using the 'rhs' method. >>> print(l.rhs()) Matrix([[Derivative(q(t), t)], [(-b*Derivative(q(t), t) - 1.0*k*q(t))/m]]) Please refer to the docstrings on each method for more details. Nc[[U5/5UlSUl[5Ul[5Ul[5Ul[5Ul[5UlU(aUO/n[U5(d [S5eX0l U(a [U[5(d [S5eX@lXPl[5Ul[5Ul[5Ul[5Ul[5Ul[U5(d [S5e[U5UlUR,R/[0R25UlUR4R/[0R25UlR,5 SnU"U5nU"U5n[UR/[0R25U/5UlX`lg)a2Supply the following for the initialization of LagrangesMethod. Lagrangian : Sympifyable qs : array_like The generalized coordinates hol_coneqs : array_like, optional The holonomic constraint equations nonhol_coneqs : array_like, optional The nonholonomic constraint equations forcelist : iterable, optional Takes an iterable of (Point, Vector) or (ReferenceFrame, Vector) tuples which represent the force at a point or torque on a frame. This feature is primarily to account for the nonconservative forces and/or moments. bodies : iterable, optional Takes an iterable containing the rigid bodies and particles of the system. frame : ReferenceFrame, optional Supply the inertial frame. This is used to determine the generalized forces due to non-conservative forces. Nz,Force pairs must be supplied in an iterable.z$frame must be a valid ReferenceFramez+Generalized coordinates must be an iterablec:U(a [U5$[5$Nrxs X/var/www/auris/envauris/lib/python3.13/site-packages/sympy/physics/mechanics/lagrange.py*LagrangesMethod.__init__..1fQi:&(:)rr_Leom_m_cd_m_d_f_cd_f_d lam_coeffsr TypeError _forcelist isinstancer _bodiesinertiallam_vec_term1_term2_term3_term4_qqrr _t_qdots _qdoubledotsrconeqs _hol_coneqs) self Lagrangianqs forcelistbodiesframe hol_coneqs nonhol_coneqs mat_builds r__init__LagrangesMethod.__init__isl<'*-./X H X H  (!*I  ""JK K# E>::BC C  x h h h h ||IJ J*ffkk."3"34  KK,,^->->?dff%: z* !-0 joon.?.?@  %rc ^ ^ URn[RURS5n[ UR 5nUR RU5UlURR[R5RUlUR RUR 5RUl UR(aURn[ U5n[[S[!US-5-55UlURU5*UlUR$RUR"-UlUR[R5nURUR5UlUR+U5*UlO[/US5UlUR0(arUR2m [/US5Ul[7U5HEunm [9[;UR0T 56n[=U U 4SjU55UR4U'MG O[/US5UlURUR- UR4- n U RUR5UlU R+U5*Ul XR&- Ul!URB$)zMethod to form Lagrange's equations of motion. Returns a vector of equations of motion using Lagrange's equations of the second kind. rzlam1:c3j># UH(upURTT5RU5v M* g7fr)rdot).0vfNqds r ;LagrangesMethod.form_lagranges_equations..s+$NfqQVVB]%6%6q%9%9s03)"r4dictfromkeysr5lenr2r jacobianr-rr r3Tr.r6rstrr,r&r/r"subsr$rr;r+r0 enumerateziprsumr#r%r!) r8qdsqdd_zeronr6m diffconeqsiflist without_lamrJrKs @@rform_lagranges_equations(LagrangesMethod.form_lagranges_equationsskk==!2!2A6 K gg&&s+ kk&&~'8'89;; gg&&tvv.00  ;;[[FF A!.3q1u:1E"FGDL%s33DO//++dll:DK^%6%67J#,,T->->?DJ$//(33DJ1+DK >> A1+DK"32^DNNA>?!$$N$N!N A( 1+DKkkDKK/$++= (():):;  %%h// ,xxrc"UR5$r)r`r8s r _form_eomsLagrangesMethod._form_eomss,,..rcURc [S5eUR(a/URR UR R 5$UR$)aReturns the mass matrix, which is augmented by the Lagrange multipliers, if necessary. Explanation =========== If the system is described by 'n' generalized coordinates and there are no constraint equations then an n X n matrix is returned. If there are 'n' generalized coordinates and 'm' constraint equations have been supplied during initialization then an n X (n+m) matrix is returned. The (n + m - 1)th and (n + m)th columns contain the coefficients of the Lagrange multipliers. -Need to compute the equations of motion first)r! ValueErrorr6r#row_joinr&rRrcs r mass_matrixLagrangesMethod.mass_matrixsJ" 88 LM M ;;II''(9(9: :99 rcURc [S5e[UR5n[UR5n[ U5R [XU-55n[X5R UR5nUR(a\[X!5R UR5R [X"55nURU5RU5$URU5$)z6Augments the coefficients of qdots to the mass_matrix.rg) r!rhrPr2r6rrirrjr"col_join)r8rZr[row1row2row3s rmass_matrix_full LagrangesMethod.mass_matrix_fulls 88 LM M K  1vuQA/Q{##D$4$45 ;;;'' 3<URR UR 5R UR 5$URR UR 5$)z+Augments qdots to the forcing vector above.rg)r!rhr6r4rmrtr$rcs r forcing_fullLagrangesMethod.forcing_fullsb 88 LM M ;;;;'' 5>>tzzJ J;;'' 5 5rc[RnURnURnUR U5n UR n Sn U "U5n U "U5n U "U5nU "U5nUR nURnUR U5nUnU*nURnURUR-*nUR*n[U 5[U5:wd[U5[U5:wa-[SR[U5[U555e[[!X/55[U5:wa [S5e[[!X/55[U5:wa [S5e[[!XxX/55n[#[%UU55nUR'[(S9 UH,n[ U[R5U;dM#[S5e [+UUUUUUUUXxU XUUXS9$)aReturns an instance of the Linearizer class, initiated from the data in the LagrangesMethod class. This may be more desirable than using the linearize class method, as the Linearizer object will allow more efficient recalculation (i.e. about varying operating points). Parameters ========== q_ind, qd_ind : array_like, optional The independent generalized coordinates and speeds. q_dep, qd_dep : array_like, optional The dependent generalized coordinates and speeds. linear_solver : str, callable Method used to solve the several symbolic linear systems of the form ``A*x=b`` in the linearization process. If a string is supplied, it should be a valid method that can be used with the :meth:`sympy.matrices.matrixbase.MatrixBase.solve`. If a callable is supplied, it should have the format ``x = f(A, b)``, where it solves the equations and returns the solution. The default is ``'LU'`` which corresponds to SymPy's ``A.LUsolve(b)``. ``LUsolve()`` is fast to compute but will often result in divide-by-zero and thus ``nan`` results. Returns ======= Linearizer An instantiated :class:`sympy.physics.mechanics.linearize.Linearizer`. c:U(a [U5$[5$rrrs rr/LagrangesMethod.to_linearizer..Mrrz?Must supply {:} dependent coordinates, and {:} dependent speedszHMust partition q into q_ind and q_dep, with no extra or missing symbols.zKMust partition qd into qd_ind and qd_dep, with no extra or missing symbols.)keyzpCannot have derivatives of specified quantities when linearizing forcing terms. linear_solver)r r3r2r4rr,r7r6r-r.r0r/rPrhformatsetrlistr sortrr)r8q_indqd_indq_depqd_depr~tr2uudlamsr@q_iq_du_iu_df_cf_vf_af_0f_1f_2f_3f_4insymsrr]s r to_linearizerLagrangesMethod.to_linearizer$sD    FF KK VVAY||: kkhhqkbkk dkk)*{{l s8s3x 3s8s3x#7+,2F3s8SX,FH H vsj! "c!f ,34 4 vsj! "c!f ,89 9 VQ2,-. $S&1 2 #$AA~(()Q. "MNN #sCc3S!CDO Orc fURXX4US9nUR"S0UD6nXR4-$)agLinearize the equations of motion about a symbolic operating point. Parameters ========== linear_solver : str, callable Method used to solve the several symbolic linear systems of the form ``A*x=b`` in the linearization process. If a string is supplied, it should be a valid method that can be used with the :meth:`sympy.matrices.matrixbase.MatrixBase.solve`. If a callable is supplied, it should have the format ``x = f(A, b)``, where it solves the equations and returns the solution. The default is ``'LU'`` which corresponds to SymPy's ``A.LUsolve(b)``. ``LUsolve()`` is fast to compute but will often result in divide-by-zero and thus ``nan`` results. **kwargs Extra keyword arguments are passed to :meth:`sympy.physics.mechanics.linearize.Linearizer.linearize`. Explanation =========== If kwarg A_and_B is False (default), returns M, A, B, r for the linearized form, M*[q', u']^T = A*[q_ind, u_ind]^T + B*r. If kwarg A_and_B is True, returns A, B, r for the linearized form dx = A*x + B*r, where x = [q_ind, u_ind]^T. Note that this is computationally intensive if there are many symbolic parameters. For this reason, it may be more desirable to use the default A_and_B=False, returning M, A, and B. Values may then be substituted in to these matrices, and the state space form found as A = P.T*M.inv()*A, B = P.T*M.inv()*B, where P = Linearizer.perm_mat. In both cases, r is found as all dynamicsymbols in the equations of motion that are not part of q, u, q', or u'. They are sorted in canonical form. The operating points may be also entered using the ``op_point`` kwarg. This takes a dictionary of {symbol: value}, or a an iterable of such dictionaries. The values may be numeric or symbolic. The more values you can specify beforehand, the faster this computation will run. For more documentation, please see the ``Linearizer`` class.r})r linearizer) r8rrrrr~kwargs linearizerresults rrLagrangesMethod.linearizewsDZ''u6C(E %%//''rc[UR5nUS:Xa [S5e[U[5(aUnO>[ U5(a0nUHnUR U5 M OUc0nO [S5eURRURR[X355*5nURRUR5n[Xd5n[Xt5nUR!U*5U*SnUS:Xa[ [#URU55$US:Xa [%U5$[SR'U55e)aSolves for the values of the lagrange multipliers symbolically at the specified operating point. Parameters ========== op_point : dict or iterable of dicts, optional Point at which to solve at. The operating point is specified as a dictionary or iterable of dictionaries of {symbol: value}. The value may be numeric or symbolic itself. sol_type : str, optional Solution return type. Valid options are: - 'dict': A dict of {symbol : value} (default) - 'Matrix': An ordered column matrix of the solution rz0System has no lagrange multipliers to solve for.NzDop_point must be either a dictionary or an iterable of dictionaries.rNrzUnknown sol_type {:}.)rPr,rhr)rNrupdater'rjrmr&rirrtr$r LUsolverVrr) r8op_pointsol_typek op_point_dictoprj force_matrixsol_lists rsolve_multipliers!LagrangesMethod.solve_multiplierss@&   6OP P h % %$M h  M$$R(  M89 9&&//1I1Ia 21 ||,,TZZ8 K7 \9 && }5qbc: v DLL(34 4  !(# #4;;HEF Frc Uc6URRUR5UlUR$URR USS9UR-UlUR$)zReturns equations that can be solved numerically. Parameters ========== inv_method : str The specific sympy inverse matrix calculation method to use. For a list of valid methods, see :meth:`~sympy.matrices.matrixbase.MatrixBase.inv` T)try_block_diag)rqrrw_rhsinv)r8 inv_methodrs rrhsLagrangesMethod.rhssq  --55d6G6GHDIyy..22:(,3.040A0ABDIyyrcUR$r)r1rcs rr2LagrangesMethod.qs wwrcUR$r)r4rcs rrLagrangesMethod.us {{rcUR$r)r*rcs rr<LagrangesMethod.bodiess ||rcUR$rr(rcs rr;LagrangesMethod.forcelist rcUR$rrrcs rloadsLagrangesMethod.loadsrr)r r*r$r%r(r7r"r#r1r4r5rr-r.r/r0r6r!r+r&r,)NNNNN)NNNNLU)NrNr)__name__ __module__ __qualname____firstlineno____doc__rAr`rdpropertyrjrqrtrwrrrrr2rr<r;r__static_attributes__rrrrr sYvKO04C&J6p/. ' '66IM$(QOfEI $0(d0Gd&rN)sympyrrrrrsympy.core.sortingrsympy.physics.vectorr r sympy.physics.mechanics.methodr !sympy.physics.mechanics.functionsr r rr!sympy.physics.mechanics.linearizersympy.utilities.iterablesr__all__rrrrrs<33/?3GG8.  shsr