class_docstr: 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``.
code: def force(self, force):
      if hasattr(self, "_force"):
          msg = (
              f"Can't set attribute `force` to {repr(force)} as it is "
              f"immutable."
          )
          raise AttributeError(msg)
      self._force = sympify(force, strict=True)
  
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 3 for calling the ForceActuator obj's underlying member method code with example usage: obj.force(force) without return types