switching to high quality piper tts and added label translations
This commit is contained in:
Matthias Hinrichs
@@ -0,0 +1,318 @@
|
||||
from sympy.physics.mechanics import (Body, Lagrangian, KanesMethod, LagrangesMethod,
|
||||
RigidBody, Particle)
|
||||
from sympy.physics.mechanics.body_base import BodyBase
|
||||
from sympy.physics.mechanics.method import _Methods
|
||||
from sympy import Matrix
|
||||
from sympy.utilities.exceptions import sympy_deprecation_warning
|
||||
|
||||
__all__ = ['JointsMethod']
|
||||
|
||||
|
||||
class JointsMethod(_Methods):
|
||||
"""Method for formulating the equations of motion using a set of interconnected bodies with joints.
|
||||
|
||||
.. deprecated:: 1.13
|
||||
The JointsMethod class is deprecated. Its functionality has been
|
||||
replaced by the new :class:`~.System` class.
|
||||
|
||||
Parameters
|
||||
==========
|
||||
|
||||
newtonion : Body or ReferenceFrame
|
||||
The newtonion(inertial) frame.
|
||||
*joints : Joint
|
||||
The joints in the system
|
||||
|
||||
Attributes
|
||||
==========
|
||||
|
||||
q, u : iterable
|
||||
Iterable of the generalized coordinates and speeds
|
||||
bodies : iterable
|
||||
Iterable of Body objects in the system.
|
||||
loads : iterable
|
||||
Iterable of (Point, vector) or (ReferenceFrame, vector) tuples
|
||||
describing the forces on the system.
|
||||
mass_matrix : Matrix, shape(n, n)
|
||||
The system's mass matrix
|
||||
forcing : Matrix, shape(n, 1)
|
||||
The system's forcing vector
|
||||
mass_matrix_full : Matrix, shape(2*n, 2*n)
|
||||
The "mass matrix" for the u's and q's
|
||||
forcing_full : Matrix, shape(2*n, 1)
|
||||
The "forcing vector" for the u's and q's
|
||||
method : KanesMethod or Lagrange's method
|
||||
Method's object.
|
||||
kdes : iterable
|
||||
Iterable of kde in they system.
|
||||
|
||||
Examples
|
||||
========
|
||||
|
||||
As Body and JointsMethod have been deprecated, the following examples are
|
||||
for illustrative purposes only. The functionality of Body is fully captured
|
||||
by :class:`~.RigidBody` and :class:`~.Particle` and the functionality of
|
||||
JointsMethod is fully captured by :class:`~.System`. To ignore the
|
||||
deprecation warning we can use the ignore_warnings context manager.
|
||||
|
||||
>>> from sympy.utilities.exceptions import ignore_warnings
|
||||
|
||||
This is a simple example for a one degree of freedom translational
|
||||
spring-mass-damper.
|
||||
|
||||
>>> from sympy import symbols
|
||||
>>> from sympy.physics.mechanics import Body, JointsMethod, PrismaticJoint
|
||||
>>> from sympy.physics.vector import dynamicsymbols
|
||||
>>> c, k = symbols('c k')
|
||||
>>> x, v = dynamicsymbols('x v')
|
||||
>>> with ignore_warnings(DeprecationWarning):
|
||||
... wall = Body('W')
|
||||
... body = Body('B')
|
||||
>>> J = PrismaticJoint('J', wall, body, coordinates=x, speeds=v)
|
||||
>>> wall.apply_force(c*v*wall.x, reaction_body=body)
|
||||
>>> wall.apply_force(k*x*wall.x, reaction_body=body)
|
||||
>>> with ignore_warnings(DeprecationWarning):
|
||||
... method = JointsMethod(wall, J)
|
||||
>>> method.form_eoms()
|
||||
Matrix([[-B_mass*Derivative(v(t), t) - c*v(t) - k*x(t)]])
|
||||
>>> M = method.mass_matrix_full
|
||||
>>> F = method.forcing_full
|
||||
>>> rhs = M.LUsolve(F)
|
||||
>>> rhs
|
||||
Matrix([
|
||||
[ v(t)],
|
||||
[(-c*v(t) - k*x(t))/B_mass]])
|
||||
|
||||
Notes
|
||||
=====
|
||||
|
||||
``JointsMethod`` currently only works with systems that do not have any
|
||||
configuration or motion constraints.
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, newtonion, *joints):
|
||||
sympy_deprecation_warning(
|
||||
"""
|
||||
The JointsMethod class is deprecated.
|
||||
Its functionality has been replaced by the new System class.
|
||||
""",
|
||||
deprecated_since_version="1.13",
|
||||
active_deprecations_target="deprecated-mechanics-jointsmethod"
|
||||
)
|
||||
if isinstance(newtonion, BodyBase):
|
||||
self.frame = newtonion.frame
|
||||
else:
|
||||
self.frame = newtonion
|
||||
|
||||
self._joints = joints
|
||||
self._bodies = self._generate_bodylist()
|
||||
self._loads = self._generate_loadlist()
|
||||
self._q = self._generate_q()
|
||||
self._u = self._generate_u()
|
||||
self._kdes = self._generate_kdes()
|
||||
|
||||
self._method = None
|
||||
|
||||
@property
|
||||
def bodies(self):
|
||||
"""List of bodies in they system."""
|
||||
return self._bodies
|
||||
|
||||
@property
|
||||
def loads(self):
|
||||
"""List of loads on the system."""
|
||||
return self._loads
|
||||
|
||||
@property
|
||||
def q(self):
|
||||
"""List of the generalized coordinates."""
|
||||
return self._q
|
||||
|
||||
@property
|
||||
def u(self):
|
||||
"""List of the generalized speeds."""
|
||||
return self._u
|
||||
|
||||
@property
|
||||
def kdes(self):
|
||||
"""List of the generalized coordinates."""
|
||||
return self._kdes
|
||||
|
||||
@property
|
||||
def forcing_full(self):
|
||||
"""The "forcing vector" for the u's and q's."""
|
||||
return self.method.forcing_full
|
||||
|
||||
@property
|
||||
def mass_matrix_full(self):
|
||||
"""The "mass matrix" for the u's and q's."""
|
||||
return self.method.mass_matrix_full
|
||||
|
||||
@property
|
||||
def mass_matrix(self):
|
||||
"""The system's mass matrix."""
|
||||
return self.method.mass_matrix
|
||||
|
||||
@property
|
||||
def forcing(self):
|
||||
"""The system's forcing vector."""
|
||||
return self.method.forcing
|
||||
|
||||
@property
|
||||
def method(self):
|
||||
"""Object of method used to form equations of systems."""
|
||||
return self._method
|
||||
|
||||
def _generate_bodylist(self):
|
||||
bodies = []
|
||||
for joint in self._joints:
|
||||
if joint.child not in bodies:
|
||||
bodies.append(joint.child)
|
||||
if joint.parent not in bodies:
|
||||
bodies.append(joint.parent)
|
||||
return bodies
|
||||
|
||||
def _generate_loadlist(self):
|
||||
load_list = []
|
||||
for body in self.bodies:
|
||||
if isinstance(body, Body):
|
||||
load_list.extend(body.loads)
|
||||
return load_list
|
||||
|
||||
def _generate_q(self):
|
||||
q_ind = []
|
||||
for joint in self._joints:
|
||||
for coordinate in joint.coordinates:
|
||||
if coordinate in q_ind:
|
||||
raise ValueError('Coordinates of joints should be unique.')
|
||||
q_ind.append(coordinate)
|
||||
return Matrix(q_ind)
|
||||
|
||||
def _generate_u(self):
|
||||
u_ind = []
|
||||
for joint in self._joints:
|
||||
for speed in joint.speeds:
|
||||
if speed in u_ind:
|
||||
raise ValueError('Speeds of joints should be unique.')
|
||||
u_ind.append(speed)
|
||||
return Matrix(u_ind)
|
||||
|
||||
def _generate_kdes(self):
|
||||
kd_ind = Matrix(1, 0, []).T
|
||||
for joint in self._joints:
|
||||
kd_ind = kd_ind.col_join(joint.kdes)
|
||||
return kd_ind
|
||||
|
||||
def _convert_bodies(self):
|
||||
# Convert `Body` to `Particle` and `RigidBody`
|
||||
bodylist = []
|
||||
for body in self.bodies:
|
||||
if not isinstance(body, Body):
|
||||
bodylist.append(body)
|
||||
continue
|
||||
if body.is_rigidbody:
|
||||
rb = RigidBody(body.name, body.masscenter, body.frame, body.mass,
|
||||
(body.central_inertia, body.masscenter))
|
||||
rb.potential_energy = body.potential_energy
|
||||
bodylist.append(rb)
|
||||
else:
|
||||
part = Particle(body.name, body.masscenter, body.mass)
|
||||
part.potential_energy = body.potential_energy
|
||||
bodylist.append(part)
|
||||
return bodylist
|
||||
|
||||
def form_eoms(self, method=KanesMethod):
|
||||
"""Method to form system's equation of motions.
|
||||
|
||||
Parameters
|
||||
==========
|
||||
|
||||
method : Class
|
||||
Class name of method.
|
||||
|
||||
Returns
|
||||
========
|
||||
|
||||
Matrix
|
||||
Vector of equations of motions.
|
||||
|
||||
Examples
|
||||
========
|
||||
|
||||
As Body and JointsMethod have been deprecated, the following examples
|
||||
are for illustrative purposes only. The functionality of Body is fully
|
||||
captured by :class:`~.RigidBody` and :class:`~.Particle` and the
|
||||
functionality of JointsMethod is fully captured by :class:`~.System`. To
|
||||
ignore the deprecation warning we can use the ignore_warnings context
|
||||
manager.
|
||||
|
||||
>>> from sympy.utilities.exceptions import ignore_warnings
|
||||
|
||||
This is a simple example for a one degree of freedom translational
|
||||
spring-mass-damper.
|
||||
|
||||
>>> from sympy import S, symbols
|
||||
>>> from sympy.physics.mechanics import LagrangesMethod, dynamicsymbols, Body
|
||||
>>> from sympy.physics.mechanics import PrismaticJoint, JointsMethod
|
||||
>>> q = dynamicsymbols('q')
|
||||
>>> qd = dynamicsymbols('q', 1)
|
||||
>>> m, k, b = symbols('m k b')
|
||||
>>> with ignore_warnings(DeprecationWarning):
|
||||
... wall = Body('W')
|
||||
... part = Body('P', mass=m)
|
||||
>>> part.potential_energy = k * q**2 / S(2)
|
||||
>>> J = PrismaticJoint('J', wall, part, coordinates=q, speeds=qd)
|
||||
>>> wall.apply_force(b * qd * wall.x, reaction_body=part)
|
||||
>>> with ignore_warnings(DeprecationWarning):
|
||||
... method = JointsMethod(wall, J)
|
||||
>>> method.form_eoms(LagrangesMethod)
|
||||
Matrix([[b*Derivative(q(t), t) + k*q(t) + m*Derivative(q(t), (t, 2))]])
|
||||
|
||||
We can also solve for the states using the 'rhs' method.
|
||||
|
||||
>>> method.rhs()
|
||||
Matrix([
|
||||
[ Derivative(q(t), t)],
|
||||
[(-b*Derivative(q(t), t) - k*q(t))/m]])
|
||||
|
||||
"""
|
||||
|
||||
bodylist = self._convert_bodies()
|
||||
if issubclass(method, LagrangesMethod): #LagrangesMethod or similar
|
||||
L = Lagrangian(self.frame, *bodylist)
|
||||
self._method = method(L, self.q, self.loads, bodylist, self.frame)
|
||||
else: #KanesMethod or similar
|
||||
self._method = method(self.frame, q_ind=self.q, u_ind=self.u, kd_eqs=self.kdes,
|
||||
forcelist=self.loads, bodies=bodylist)
|
||||
soln = self.method._form_eoms()
|
||||
return soln
|
||||
|
||||
def rhs(self, inv_method=None):
|
||||
"""Returns 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`
|
||||
|
||||
Returns
|
||||
========
|
||||
|
||||
Matrix
|
||||
Numerically solvable equations.
|
||||
|
||||
See Also
|
||||
========
|
||||
|
||||
sympy.physics.mechanics.kane.KanesMethod.rhs:
|
||||
KanesMethod's rhs function.
|
||||
sympy.physics.mechanics.lagrange.LagrangesMethod.rhs:
|
||||
LagrangesMethod's rhs function.
|
||||
|
||||
"""
|
||||
|
||||
return self.method.rhs(inv_method=inv_method)
|
||||
Reference in New Issue
Block a user