class_docstr: A 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.
docstr: Initializer 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``.
docstr_tok: ["Initializer","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","``","."]
code: def __init__(self, damping, pathway):
      """Initializer 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``.
  
      """
      self.damping = damping
      self.pathway = pathway
  
imports: from abc import ABC, abstractmethod
  from sympy import S, sympify
  from sympy.physics.mechanics.joint import PinJoint
  from sympy.physics.mechanics.loads import Torque
  from sympy.physics.mechanics.pathway import PathwayBase
  from sympy.physics.mechanics.rigidbody import RigidBody
  from sympy.physics.vector import ReferenceFrame, Vector
label_desc: Use image node_id 1 to create a new LinearDamper object from inherited base classes: ForceActuator with example: obj = LinearDamper(damping, pathway)