\hqSrSSKJrJr SSKJrJrJrJr SSK J r SSK J r SSK Jr SSKJr SSKJrJr /S Qr"S S \5r"S S \5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5rg)zEImplementations of actuators for linked force and torque application.)ABCabstractmethod)Ssympifyexpsign)PinJoint)Torque) PathwayBase) RigidBody)ReferenceFrameVector) ActuatorBase ForceActuator LinearDamper LinearSpringTorqueActuator DuffingSpringCoulombKineticFrictionc4\rSrSrSrSr\S5rSrSr g)rzAbstract base class for all actuator classes to inherit from. Notes ===== Instances of this class cannot be directly instantiated by users. However, it can be used to created custom actuator types through subclassing. cg)z!Initializer for ``ActuatorBase``.Nselfs X/var/www/auris/envauris/lib/python3.13/site-packages/sympy/physics/mechanics/actuator.py__init__ActuatorBase.__init__#s cg)atLoads required by the equations of motion method classes. Explanation =========== ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be passed to the ``loads`` parameters of its ``kanes_equations`` method when constructing the equations of motion. This method acts as a utility to produce the correctly-structred pairs of points and vectors required so that these can be easily concatenated with other items in the list of loads and passed to ``KanesMethod.kanes_equations``. These loads are also in the correct form to also be passed to the other equations of motion method classes, e.g. ``LagrangesMethod``. Nrrs rto_loadsActuatorBase.to_loads's" rc4URRS3$)z&Default representation of an actuator.z()) __class____name__rs r__repr__ActuatorBase.__repr__:s..))*"--rrN) r% __module__ __qualname____firstlineno____doc__rrr!r&__static_attributes__rrrrrs%   $.rrc\rSrSrSrSr\S5r\RS5r\S5r \ RS5r Sr S r S r g ) r?a Force-producing actuator. Explanation =========== A ``ForceActuator`` is an actuator that produces a (expansile) force along its length. A force actuator uses a pathway instance to determine the direction and number of forces that it applies to a system. Consider the simplest case where a ``LinearPathway`` instance is used. This pathway is made up of two points that can move relative to each other, and results in a pair of equal and opposite forces acting on the endpoints. If the positive time-varying Euclidean distance between the two points is defined, then the "extension velocity" is the time derivative of this distance. The extension velocity is positive when the two points are moving away from each other and negative when moving closer to each other. The direction for the force acting on either point is determined by constructing a unit vector directed from the other point to this point. This establishes a sign convention such that a positive force magnitude tends to push the points apart, this is the meaning of "expansile" in this context. The following diagram shows the positive force sense and the distance between the points:: P Q o<--- F --->o | | |<--l(t)--->| Examples ======== To construct an actuator, an expression (or symbol) must be supplied to represent the force it can produce, alongside a pathway specifying its line of action. Let's also create a global reference frame and spatially fix one of the points in it while setting the other to be positioned such that it can freely move in the frame's x direction specified by the coordinate ``q``. >>> from sympy import symbols >>> from sympy.physics.mechanics import (ForceActuator, LinearPathway, ... Point, ReferenceFrame) >>> from sympy.physics.vector import dynamicsymbols >>> N = ReferenceFrame('N') >>> q = dynamicsymbols('q') >>> force = symbols('F') >>> pA, pB = Point('pA'), Point('pB') >>> pA.set_vel(N, 0) >>> pB.set_pos(pA, q*N.x) >>> pB.pos_from(pA) q(t)*N.x >>> linear_pathway = LinearPathway(pA, pB) >>> actuator = ForceActuator(force, linear_pathway) >>> actuator ForceActuator(F, LinearPathway(pA, pB)) Parameters ========== force : Expr The scalar expression defining the (expansile) force that the actuator produces. pathway : PathwayBase The pathway that the actuator follows. This must be an instance of a concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``. cXlX lg)aCInitializer for ``ForceActuator``. Parameters ========== force : Expr The scalar expression defining the (expansile) force that the actuator produces. pathway : PathwayBase The pathway that the actuator follows. This must be an instance of a concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``. N)forcepathway)rr0r1s rrForceActuator.__init__s  rcUR$)z4The magnitude of the force produced by the actuator.)_forcers rr0ForceActuator.force{{rcx[US5(aS[U5S3n[U5e[USS9UlgNr4zCan't set attribute `force` to  as it is immutable.TstricthasattrreprAttributeErrorrr4rr0msgs rr0r5E 4 " "24;-@ !% %eD1 rcUR$)z7The ``Pathway`` defining the actuator's line of action._pathwayrs rr1ForceActuator.pathway}}rc[US5(aS[U5S3n[U5e[U[5(d-S[U5S[ U5S[S3n[ U5eXlgNrEz!Can't set attribute `pathway` to r9Value z! passed to `pathway` was of type , must be .r=r>r? isinstancer type TypeErrorrErr1rAs rr1rF~ 4 $ $4T']OD !% %';//g'H=/K=; C.  rcLURRUR5$)ao Loads required by the equations of motion method classes. Explanation =========== ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be passed to the ``loads`` parameters of its ``kanes_equations`` method when constructing the equations of motion. This method acts as a utility to produce the correctly-structred pairs of points and vectors required so that these can be easily concatenated with other items in the list of loads and passed to ``KanesMethod.kanes_equations``. These loads are also in the correct form to also be passed to the other equations of motion method classes, e.g. ``LagrangesMethod``. Examples ======== The below example shows how to generate the loads produced by a force actuator that follows a linear pathway. In this example we'll assume that the force actuator is being used to model a simple linear spring. First, create a linear pathway between two points separated by the coordinate ``q`` in the ``x`` direction of the global frame ``N``. >>> from sympy.physics.mechanics import (LinearPathway, Point, ... ReferenceFrame) >>> from sympy.physics.vector import dynamicsymbols >>> q = dynamicsymbols('q') >>> N = ReferenceFrame('N') >>> pA, pB = Point('pA'), Point('pB') >>> pB.set_pos(pA, q*N.x) >>> pathway = LinearPathway(pA, pB) Now create a symbol ``k`` to describe the spring's stiffness and instantiate a force actuator that produces a (contractile) force proportional to both the spring's stiffness and the pathway's length. Note that actuator classes use the sign convention that expansile forces are positive, so for a spring to produce a contractile force the spring force needs to be calculated as the negative for the stiffness multiplied by the length. >>> from sympy import symbols >>> from sympy.physics.mechanics import ForceActuator >>> stiffness = symbols('k') >>> spring_force = -stiffness*pathway.length >>> spring = ForceActuator(spring_force, pathway) The forces produced by the spring can be generated in the list of loads form that ``KanesMethod`` (and other equations of motion methods) requires by calling the ``to_loads`` method. >>> spring.to_loads() [(pA, k*q(t)*N.x), (pB, - k*q(t)*N.x)] A simple linear damper can be modeled in a similar way. Create another symbol ``c`` to describe the dampers damping coefficient. This time instantiate a force actuator that produces a force proportional to both the damper's damping coefficient and the pathway's extension velocity. Note that the damping force is negative as it acts in the opposite direction to which the damper is changing in length. >>> damping_coefficient = symbols('c') >>> damping_force = -damping_coefficient*pathway.extension_velocity >>> damper = ForceActuator(damping_force, pathway) Again, the forces produces by the damper can be generated by calling the ``to_loads`` method. >>> damper.to_loads() [(pA, c*Derivative(q(t), t)*N.x), (pB, - c*Derivative(q(t), t)*N.x)] )r1r!r0rs rr!ForceActuator.to_loadssP||$$TZZ00rchURRSURSURS3$)z&Representation of a ``ForceActuator``.(, ))r$r%r0r1rs rr&ForceActuator.__repr__s...))*!DJJo | | |<--l(t)--->| Examples ======== To construct a linear spring, an expression (or symbol) must be supplied to represent the stiffness (spring constant) of the spring, alongside a pathway specifying its line of action. Let's also create a global reference frame and spatially fix one of the points in it while setting the other to be positioned such that it can freely move in the frame's x direction specified by the coordinate ``q``. >>> from sympy import symbols >>> from sympy.physics.mechanics import (LinearPathway, LinearSpring, ... Point, ReferenceFrame) >>> from sympy.physics.vector import dynamicsymbols >>> N = ReferenceFrame('N') >>> q = dynamicsymbols('q') >>> stiffness = symbols('k') >>> pA, pB = Point('pA'), Point('pB') >>> pA.set_vel(N, 0) >>> pB.set_pos(pA, q*N.x) >>> pB.pos_from(pA) q(t)*N.x >>> linear_pathway = LinearPathway(pA, pB) >>> spring = LinearSpring(stiffness, linear_pathway) >>> spring LinearSpring(k, LinearPathway(pA, pB)) This spring will produce a force that is proportional to both its stiffness and the pathway's length. Note that this force is negative as SymPy's sign convention for actuators is that negative forces are contractile. >>> spring.force -k*sqrt(q(t)**2) To create a linear spring with a non-zero equilibrium length, an expression (or symbol) can be passed to the ``equilibrium_length`` parameter on construction on a ``LinearSpring`` instance. Let's create a symbol ``l`` to denote a non-zero equilibrium length and create another linear spring. >>> l = symbols('l') >>> spring = LinearSpring(stiffness, linear_pathway, equilibrium_length=l) >>> spring LinearSpring(k, LinearPathway(pA, pB), equilibrium_length=l) The spring force of this new spring is again proportional to both its stiffness and the pathway's length. However, the spring will not produce any force when ``q(t)`` equals ``l``. Note that the force will become expansile when ``q(t)`` is less than ``l``, as expected. >>> spring.force -k*(-l + sqrt(q(t)**2)) Parameters ========== stiffness : Expr The spring constant. pathway : PathwayBase The pathway that the actuator follows. This must be an instance of a concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``. equilibrium_length : Expr, optional The length at which the spring is in equilibrium, i.e. it produces no force. The default value is 0, i.e. the spring force is a linear function of the pathway's length with no constant offset. See Also ======== ForceActuator: force-producing actuator (superclass of ``LinearSpring``). LinearPathway: straight-line pathway between a pair of points. c(XlX lX0lg)aInitializer for ``LinearSpring``. Parameters ========== stiffness : Expr The spring constant. pathway : PathwayBase The pathway that the actuator follows. This must be an instance of a concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``. equilibrium_length : Expr, optional The length at which the spring is in equilibrium, i.e. it produces no force. The default value is 0, i.e. the spring force is a linear function of the pathway's length with no constant offset. N) stiffnessr1equilibrium_length)rr^r1r_s rrLinearSpring.__init__ps"# "4rcdUR*URRUR- -$)z/The spring force produced by the linear spring.)r^r1lengthr_rs rr0LinearSpring.forces* 3 3d6M6M MNNrc[S5eNz%Can't set computed attribute `force`.r?rr0s rr0rcEFFrcUR$)z*The spring constant for the linear spring.) _stiffnessrs rr^LinearSpring.stiffnesssrcx[US5(aS[U5S3n[U5e[USS9Ulg)Nrjz#Can't set attribute `stiffness` to r9Tr:)r=r>r?rrj)rr^rAs rr^rksF 4 & &6tI6GH ! !% %!)D9rcUR$)z7The length of the spring at which it produces no force._equilibrium_lengthrs rr_LinearSpring.equilibrium_lengths'''rcx[US5(aS[U5S3n[U5e[USS9UlgNroz,Can't set attribute `equilibrium_length` to r9Tr:r=r>r?rrorr_rAs rr_rpJ 4. / /?*+,,@B !% %#*+=d#K rcURRSURSUR3nUR[ R :XaUS- nU$USURS3- nU$)z%Representation of a ``LinearSpring``.rVrWrX, equilibrium_length=)r$r%r^r1r_rZerorstrings rr&LinearSpring.__repr__spNN++,Adnn-=R ~N  " "aff , cMF  -d.E.E-FaH HF r)rorjr_r1r^N)r%r(r)r*r+rrxrrZr0r[r^r_r&r,rrrrrsfP?@ff5*OO \\GG::((LLrrc\rSrSrSrSr\S5r\RS5r\S5r \ RS5r Sr S r g ) riaA damper whose force is a linear function of its extension velocity. Explanation =========== Note that the "linear" in the name ``LinearDamper`` refers to the fact that the damping force is a linear function of the damper's rate of change in its length. I.e. for a linear damper with damping ``c`` and extension velocity ``v``, the damping force will be ``-c*v``, which is a linear function in ``v``. To create a damper that follows a linear, or straight, pathway between its two ends, a ``LinearPathway`` instance needs to be passed to the ``pathway`` parameter. A ``LinearDamper`` is a subclass of ``ForceActuator`` and so follows the same sign conventions for length, extension velocity, and the direction of the forces it applies to its points of attachment on bodies. The sign convention for the direction of forces is such that, for the case where a linear damper is instantiated with a ``LinearPathway`` instance as its pathway, they act to push the two ends of the damper away from one another. Because dampers produce a force that opposes the direction of change in length, when extension velocity is positive the scalar portions of the forces applied at the two endpoints are negative in order to flip the sign of the forces on the endpoints wen converted into vector quantities. When extension velocity is negative (i.e. when the damper is shortening), the scalar portions of the fofces applied are also negative so that the signs cancel producing forces on the endpoints that are in the same direction as the positive sign convention for the forces at the endpoints of the pathway (i.e. they act to push the endpoints away from one another). The following diagram shows the positive force sense and the distance between the points:: P Q o<--- F --->o | | |<--l(t)--->| Examples ======== To construct a linear damper, an expression (or symbol) must be supplied to represent the damping coefficient of the damper (we'll use the symbol ``c``), alongside a pathway specifying its line of action. Let's also create a global reference frame and spatially fix one of the points in it while setting the other to be positioned such that it can freely move in the frame's x direction specified by the coordinate ``q``. The velocity that the two points move away from one another can be specified by the coordinate ``u`` where ``u`` is the first time derivative of ``q`` (i.e., ``u = Derivative(q(t), t)``). >>> from sympy import symbols >>> from sympy.physics.mechanics import (LinearDamper, LinearPathway, ... Point, ReferenceFrame) >>> from sympy.physics.vector import dynamicsymbols >>> N = ReferenceFrame('N') >>> q = dynamicsymbols('q') >>> damping = symbols('c') >>> pA, pB = Point('pA'), Point('pB') >>> pA.set_vel(N, 0) >>> pB.set_pos(pA, q*N.x) >>> pB.pos_from(pA) q(t)*N.x >>> pB.vel(N) Derivative(q(t), t)*N.x >>> linear_pathway = LinearPathway(pA, pB) >>> damper = LinearDamper(damping, linear_pathway) >>> damper LinearDamper(c, LinearPathway(pA, pB)) This damper will produce a force that is proportional to both its damping coefficient and the pathway's extension length. Note that this force is negative as SymPy's sign convention for actuators is that negative forces are contractile and the damping force of the damper will oppose the direction of length change. >>> damper.force -c*sqrt(q(t)**2)*Derivative(q(t), t)/q(t) Parameters ========== damping : Expr The damping constant. pathway : PathwayBase The pathway that the actuator follows. This must be an instance of a concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``. See Also ======== ForceActuator: force-producing actuator (superclass of ``LinearDamper``). LinearPathway: straight-line pathway between a pair of points. cXlX lg)aInitializer for ``LinearDamper``. Parameters ========== damping : Expr The damping constant. pathway : PathwayBase The pathway that the actuator follows. This must be an instance of a concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``. N)dampingr1)rr~r1s rrLinearDamper.__init__s  rcJUR*URR-$)z0The damping force produced by the linear damper.)r~r1extension_velocityrs rr0LinearDamper.force%s }T\\<<<r?rr)rr~rAs rr~r3sE 4 $ $4T']OD !% %5 rchURRSURSURS3$)z%Representation of a ``LinearDamper``.rVrWrX)r$r%r~r1rs rr&LinearDamper.__repr__=s...))*!DLL>DLL>KKr)rr~r1N) r%r(r)r*r+rrZr0r[r~r&r,rrrrrsn\| == \\GG ^^66Lrrc\rSrSrSrSSjr\S5r\S5r \ RS5r \S5r \ RS 5r \S 5r \ RS 5r \S 5r \ RS 5r SrSrSrg)riBaTorque-producing actuator. Explanation =========== A ``TorqueActuator`` is an actuator that produces a pair of equal and opposite torques on a pair of bodies. Examples ======== To construct a torque actuator, an expression (or symbol) must be supplied to represent the torque it can produce, alongside a vector specifying the axis about which the torque will act, and a pair of frames on which the torque will act. >>> from sympy import symbols >>> from sympy.physics.mechanics import (ReferenceFrame, RigidBody, ... TorqueActuator) >>> N = ReferenceFrame('N') >>> A = ReferenceFrame('A') >>> torque = symbols('T') >>> axis = N.z >>> parent = RigidBody('parent', frame=N) >>> child = RigidBody('child', frame=A) >>> bodies = (child, parent) >>> actuator = TorqueActuator(torque, axis, *bodies) >>> actuator TorqueActuator(T, axis=N.z, target_frame=A, reaction_frame=N) Note that because torques actually act on frames, not bodies, ``TorqueActuator`` will extract the frame associated with a ``RigidBody`` when one is passed instead of a ``ReferenceFrame``. Parameters ========== torque : Expr The scalar expression defining the torque that the actuator produces. axis : Vector The axis about which the actuator applies torques. target_frame : ReferenceFrame | RigidBody The primary frame on which the actuator will apply the torque. reaction_frame : ReferenceFrame | RigidBody | None The secondary frame on which the actuator will apply the torque. Note that the (equal and opposite) reaction torque is applied to this frame. Nc4XlX lX0lX@lg)aInitializer for ``TorqueActuator``. Parameters ========== torque : Expr The scalar expression defining the torque that the actuator produces. axis : Vector The axis about which the actuator applies torques. target_frame : ReferenceFrame | RigidBody The primary frame on which the actuator will apply the torque. reaction_frame : ReferenceFrame | RigidBody | None The secondary frame on which the actuator will apply the torque. Note that the (equal and opposite) reaction torque is applied to this frame. N)torqueaxis target_framereaction_frame)rrrrrs rrTorqueActuator.__init__ts&  (,rc[U[5(d-S[U5S[U5S[S3n[ U5eU"UUR UR UR5$)aAlternate constructor to instantiate from a ``PinJoint`` instance. Examples ======== To create a pin joint the ``PinJoint`` class requires a name, parent body, and child body to be passed to its constructor. It is also possible to control the joint axis using the ``joint_axis`` keyword argument. In this example let's use the parent body's reference frame's z-axis as the joint axis. >>> from sympy.physics.mechanics import (PinJoint, ReferenceFrame, ... RigidBody, TorqueActuator) >>> N = ReferenceFrame('N') >>> A = ReferenceFrame('A') >>> parent = RigidBody('parent', frame=N) >>> child = RigidBody('child', frame=A) >>> pin_joint = PinJoint( ... 'pin', ... parent, ... child, ... joint_axis=N.z, ... ) Let's also create a symbol ``T`` that will represent the torque applied by the torque actuator. >>> from sympy import symbols >>> torque = symbols('T') To create the torque actuator from the ``torque`` and ``pin_joint`` variables previously instantiated, these can be passed to the alternate constructor class method ``at_pin_joint`` of the ``TorqueActuator`` class. It should be noted that a positive torque will cause a positive displacement of the joint coordinate or that the torque is applied on the child body with a reaction torque on the parent. >>> actuator = TorqueActuator.at_pin_joint(torque, pin_joint) >>> actuator TorqueActuator(T, axis=N.z, target_frame=A, reaction_frame=N) Parameters ========== torque : Expr The scalar expression defining the torque that the actuator produces. pin_joint : PinJoint The pin joint, and by association the parent and child bodies, on which the torque actuator will act. The pair of bodies acted upon by the torque actuator are the parent and child bodies of the pin joint, with the child acting as the reaction body. The pin joint's axis is used as the axis about which the torque actuator will apply its torque. rJz# passed to `pin_joint` was of type rKrL)rNr r>rOrP joint_axischild_interframeparent_interframe)clsr pin_jointrAs r at_pin_jointTorqueActuator.at_pin_jointstt)X..i))L ?#:hZq: C.     & &  ' '   rcUR$)z5The magnitude of the torque produced by the actuator.)_torquers rrTorqueActuator.torques||rcx[US5(aS[U5S3n[U5e[USS9Ulg)Nrz Can't set attribute `torque` to r9Tr:)r=r>r?rr)rrrAs rrrsE 4 # #3DL>B !% %vd3 rcUR$)z%The axis about which the torque acts.)_axisrs rrTorqueActuator.axiszzrc[US5(aS[U5S3n[U5e[U[5(d-S[U5S[ U5S[S3n[ U5eXlg)NrzCan't set attribute `axis` to r9rJz passed to `axis` was of type rKrL)r=r>r?rNrrOrPr)rrrAs rrrs} 4 ! !1$t*> !% %$''d $B:,j3 C.  rcUR$z:The primary reference frames on which the torque will act.) _target_framers rrTorqueActuator.target_frames!!!rc.[US5(aS[U5S3n[U5e[U[5(a UR nOB[U[ 5(d-S[U5S[U5S[ S3n[U5eXl g)Nrz&Can't set attribute `target_frame` to r9rJz& passed to `target_frame` was of type rKrL) r=r>r?rNr framer rOrPr)rrrAs rrrs 4 ) )9$|:L9MN&' !% % lI . .'--LL.99l+,-\*+:n5EQH C. )rcUR$r)_reaction_framers rrTorqueActuator.reaction_frames###rc4[US5(aS[U5S3n[U5e[U[5(a UR nOE[U[ 5(d0Ub-S[U5S[U5S[ S3n[U5eXl g)Nrz(Can't set attribute `reaction_frame` to r9rJz( passed to `reaction_frame` was of type rKrL) r=r>r?rNr rr rOrPr)rrrAs rrrs 4* + +;'((<> !% % ni 0 0+11N>>::*n-.//0 >:J!M C. -rc[URURUR-5/nURb=UR [URUR*UR-55 U$)avLoads required by the equations of motion method classes. Explanation =========== ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be passed to the ``loads`` parameters of its ``kanes_equations`` method when constructing the equations of motion. This method acts as a utility to produce the correctly-structred pairs of points and vectors required so that these can be easily concatenated with other items in the list of loads and passed to ``KanesMethod.kanes_equations``. These loads are also in the correct form to also be passed to the other equations of motion method classes, e.g. ``LagrangesMethod``. Examples ======== The below example shows how to generate the loads produced by a torque actuator that acts on a pair of bodies attached by a pin joint. >>> from sympy import symbols >>> from sympy.physics.mechanics import (PinJoint, ReferenceFrame, ... RigidBody, TorqueActuator) >>> torque = symbols('T') >>> N = ReferenceFrame('N') >>> A = ReferenceFrame('A') >>> parent = RigidBody('parent', frame=N) >>> child = RigidBody('child', frame=A) >>> pin_joint = PinJoint( ... 'pin', ... parent, ... child, ... joint_axis=N.z, ... ) >>> actuator = TorqueActuator.at_pin_joint(torque, pin_joint) The forces produces by the damper can be generated by calling the ``to_loads`` method. >>> actuator.to_loads() [(A, T*N.z), (N, - T*N.z)] Alternatively, if a torque actuator is created without a reaction frame then the loads returned by the ``to_loads`` method will contain just the single load acting on the target frame. >>> actuator = TorqueActuator(torque, N.z, N) >>> actuator.to_loads() [(N, T*N.z)] )r rrrrappend)rloadss rr!TorqueActuator.to_loads(sdj 4$$dkk$))&; <     * LL 3 3dkk\$))5KL M rcURRSURSURSUR3nUR bUSUR S3- nU$US- nU$)z'Representation of a ``TorqueActuator``.rVz, axis=z, target_frame=z, reaction_frame=rX)r$r%rrrrrys rr&TorqueActuator.__repr__cs~~&&'q WTYYKH --. 0     * )$*=*=)>a@ @F  cMF r)rrrrrrrrN)r%r(r)r*r+r classmethodrrZrr[rrrr!r&r,rrrrrBs/b-0D D L ]]44 [[  ""**"$$..(9v rrcB\rSrSrSr\R 4Sjr\S5r \ RS5r \S5r \ RS5r \S5r \ RS 5r \S 5r \ RS 5r \S 5r\RS 5rSrSrg)ripaA nonlinear spring based on the Duffing equation. Explanation =========== Here, ``DuffingSpring`` represents the force exerted by a nonlinear spring based on the Duffing equation: F = -beta*x-alpha*x**3, where x is the displacement from the equilibrium position, beta is the linear spring constant, and alpha is the coefficient for the nonlinear cubic term. Parameters ========== linear_stiffness : Expr The linear stiffness coefficient (beta). nonlinear_stiffness : Expr The nonlinear stiffness coefficient (alpha). pathway : PathwayBase The pathway that the actuator follows. equilibrium_length : Expr, optional The length at which the spring is in equilibrium (x). c[USS9Ul[USS9Ul[USS9Ul[ U[ 5(d [ S5eX0lg)NTr:z+pathway must be an instance of PathwayBase.)rlinear_stiffnessnonlinear_stiffnessr_rNr rPrE)rrrr1r_s rrDuffingSpring.__init__sP '(8 F#*+>t#L ")*r?rr)rrrAs rrrsJ 4, - -=()**>@ !% %!()9$!GrcUR$r)_nonlinear_stiffnessrs rr!DuffingSpring.nonlinear_stiffnesss(((rcx[US5(aS[U5S3n[U5e[USS9Ulg)Nrz-Can't set attribute `nonlinear_stiffness` to r9Tr:)r=r>r?rr)rrrAs rrrsJ 4/ 0 0@+,--AC !% %$+,?$M!rcUR$rrDrs rr1DuffingSpring.pathways }}rc[US5(aS[U5S3n[U5e[U[5(d-S[U5S[ U5S[S3n[ U5eXlgrIrMrQs rr1rrRrcUR$rrnrs rr_ DuffingSpring.equilibrium_lengths'''rcx[US5(aS[U5S3n[U5e[USS9Ulgrrrsrts rr_rrurcURRUR- nUR*U-URUS--- $)z)The force produced by the Duffing spring.)r1rbr_rr)r displacements rr0DuffingSpring.forcesI||**T-D-DD %%% 4t7O7OR^`aRa7aaarcx[US5(aS[U5S3n[U5e[USS9Ulgr8r<r@s rr0rrBrc URRSURSURSURSUR S3 $)NrVrWrwrX)r$r%rrr1r_rs rr&DuffingSpring.__repr__sW>>**+1(()D,D,D+ER ~V&&*&=&=%>aA Br)ror4rrrEr_rrN)r%r(r)r*r+rrxrrZrr[rr1r_r0r&r,rrrrrps ,[\Z`Z` &&HH))N N ^^    ((LLbb  \\22Brrc\rSrSrSrSSSS.Sjr\S5r\S5r\S5r \S 5r \S 5r \S 5r \ RS 5r S rSrg)ria1Coulomb kinetic friction with Stribeck and viscous effects. Explanation =========== This represents a Coulomb kinetic friction with the Stribeck and viscous effect, described by the function: .. math:: F = (\mu_k f_n + (\mu_s - \mu_k) f_n e^{-(\frac{v}{v_s})^2}) \text{sign}(v) + \sigma v where :math:`\mu_k` is the coefficient of kinetic friction, :math:`\mu_s` is the coefficient of static friction, :math:`f_n` is the normal force, :math:`v` is the relative velocity, :math:`v_s` is the Stribeck friction coefficient, and :math:`\sigma` is the viscous friction constant. The default friction force is :math:`F = \mu_k f_n`. When specified, the actuator includes: - Stribeck effect: :math:`(\mu_s - \mu_k) f_n e^{-(\frac{v}{v_s})^2}` - Viscous effect: :math:`\sigma v` Notes ===== The actuator makes the following assumptions: - The actuator assumes relative motion is non-zero. - The normal force is assumed to be a non-negative scalar. - The resultant friction force is opposite to the velocity direction. - Each point in the pathway is fixed within separate objects that are sliding relative to each other. In other words, these two points are fixed in the mutually sliding objects. This actuator has been tested for straightforward motions, like a block sliding on a surface. The friction force is defined to always oppose the direction of relative velocity :math:`v`. Specifically: - The default Coulomb friction force :math:`\mu_k f_n \text{sign}(v)` is opposite to :math:`v`. - The Stribeck effect :math:`(\mu_s - \mu_k) f_n e^{-(\frac{v}{v_s})^2} \text{sign}(v)` is also opposite to :math:`v`. - The viscous friction term :math:`\sigma v` is opposite to :math:`v`. Examples ======== The below example shows how to generate the loads produced by a Coulomb kinetic friction actuator in a mass-spring system with friction. >>> import sympy as sm >>> from sympy.physics.mechanics import (dynamicsymbols, ReferenceFrame, Point, ... LinearPathway, CoulombKineticFriction, LinearSpring, KanesMethod, Particle) >>> x, v = dynamicsymbols('x, v', real=True) >>> m, g, k, mu_k, mu_s, v_s, sigma = sm.symbols('m, g, k, mu_k, mu_s, v_s, sigma') >>> N = ReferenceFrame('N') >>> O, P = Point('O'), Point('P') >>> O.set_vel(N, 0) >>> P.set_pos(O, x*N.x) >>> pathway = LinearPathway(O, P) >>> friction = CoulombKineticFriction(mu_k, m*g, pathway, v_s=v_s, sigma=sigma, mu_s=mu_k) >>> spring = LinearSpring(k, pathway) >>> block = Particle('block', point=P, mass=m) >>> kane = KanesMethod(N, (x,), (v,), kd_eqs=(x.diff() - v,)) >>> friction.to_loads() [(O, (g*m*mu_k*sign(sign(x(t))*Derivative(x(t), t)) + sigma*sign(x(t))*Derivative(x(t), t))*x(t)/Abs(x(t))*N.x), (P, (-g*m*mu_k*sign(sign(x(t))*Derivative(x(t), t)) - sigma*sign(x(t))*Derivative(x(t), t))*x(t)/Abs(x(t))*N.x)] >>> loads = friction.to_loads() + spring.to_loads() >>> fr, frstar = kane.kanes_equations([block], loads) >>> eom = fr + frstar >>> eom Matrix([[-k*x(t) - m*Derivative(v(t), t) + (-g*m*mu_k*sign(v(t)*sign(x(t))) - sigma*v(t)*sign(x(t)))*x(t)/Abs(x(t))]]) Parameters ========== f_n : sympifiable The normal force between the surfaces. It should always be a non-negative scalar. mu_k : sympifiable The coefficient of kinetic friction. pathway : PathwayBase The pathway that the actuator follows. v_s : sympifiable, optional The Stribeck friction coefficient. sigma : sympifiable, optional The viscous friction coefficient. mu_s : sympifiable, optional The coefficient of static friction. Defaults to mu_k, meaning the Stribeck effect evaluates to 0 by default. References ========== .. [Moore2022] https://moorepants.github.io/learn-multibody-dynamics/loads.html#friction. .. [Flores2023] Paulo Flores, Jorge Ambrosio, Hamid M. Lankarani, "Contact-impact events with friction in multibody dynamics: Back to basics", Mechanism and Machine Theory, vol. 184, 2023. https://doi.org/10.1016/j.mechmachtheory.2023.105305. .. [Rogner2017] I. Rogner, "Friction modelling for robotic applications with planar motion", Chalmers University of Technology, Department of Electrical Engineering, 2017. N)v_ssigmamu_scUb [USS9OSUlUb [USS9O URUl[USS9UlUb [USS9OSUlUcUS:Xa [USS9OSUlX0lg)NTr:rg{Gz?)r_mu_k_mu_s_f_n_sigma_v_sr1)rmu_kf_nr1rrrs rrCoulombKineticFriction.__init__Jss373CWT$/ 373CWT$/ C- 5:5FgeD1A 14C1HGC-RV  rcUR$)z$The coefficient of kinetic friction.)rrs rrCoulombKineticFriction.mu_kRrrcUR$)z#The coefficient of static friction.)rrs rrCoulombKineticFriction.mu_sWrrcUR$)z&The normal force between the surfaces.)rrs rrCoulombKineticFriction.f_n\yyrcUR$)z!The viscous friction coefficient.)rrs rrCoulombKineticFriction.sigmaar6rcUR$)z"The Stribeck friction coefficient.)rrs rrCoulombKineticFriction.v_sfrrcTURRnURUR-nURUR-nUR b X2- [ XR - S-*5-OSnURbURU-OSnX$-[U5*-U- $)Nr) r1rrrrrrrr)rvf_cf_max stribeck_term viscous_terms rr0CoulombKineticFriction.forceks LL + +ii$((" DHH$CG88CWa((lQ->,>(??]^ )-)?tzzA~Q #Qx/,>>rc[S5ererfrgs rr0rtrhrcURRSURSURSURSUR SUR SURS3$)NrVrW rX)r$r%rrrr1rrrs rr&CoulombKineticFriction.__repr__xs\>>**+1TZZL4::,a99+R ~R {";;-q" #r)rrrrrr1)r%r(r)r*r+rrZrrrrrr0r[r&r,rrrrrsdL37d?? \\GG#rrN)r+abcrrsympyrrrrsympy.physics.mechanics.jointr sympy.physics.mechanics.loadsr sympy.physics.mechanics.pathwayr !sympy.physics.mechanics.rigidbodyr sympy.physics.vectorr r__all__rrrrrrrrrrrsK#''20777 $.3$.NEJLEJPl=l^IL=ILXk\k\ qBMqBfX#]X#r