| | from .vector import Vector, _check_vector |
| | from .frame import _check_frame |
| | from warnings import warn |
| | from sympy.utilities.misc import filldedent |
| |
|
| | __all__ = ['Point'] |
| |
|
| |
|
| | class Point: |
| | """This object represents a point in a dynamic system. |
| | |
| | It stores the: position, velocity, and acceleration of a point. |
| | The position is a vector defined as the vector distance from a parent |
| | point to this point. |
| | |
| | Parameters |
| | ========== |
| | |
| | name : string |
| | The display name of the Point |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols |
| | >>> from sympy.physics.vector import init_vprinting |
| | >>> init_vprinting(pretty_print=False) |
| | >>> N = ReferenceFrame('N') |
| | >>> O = Point('O') |
| | >>> P = Point('P') |
| | >>> u1, u2, u3 = dynamicsymbols('u1 u2 u3') |
| | >>> O.set_vel(N, u1 * N.x + u2 * N.y + u3 * N.z) |
| | >>> O.acc(N) |
| | u1'*N.x + u2'*N.y + u3'*N.z |
| | |
| | ``symbols()`` can be used to create multiple Points in a single step, for |
| | example: |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols |
| | >>> from sympy.physics.vector import init_vprinting |
| | >>> init_vprinting(pretty_print=False) |
| | >>> from sympy import symbols |
| | >>> N = ReferenceFrame('N') |
| | >>> u1, u2 = dynamicsymbols('u1 u2') |
| | >>> A, B = symbols('A B', cls=Point) |
| | >>> type(A) |
| | <class 'sympy.physics.vector.point.Point'> |
| | >>> A.set_vel(N, u1 * N.x + u2 * N.y) |
| | >>> B.set_vel(N, u2 * N.x + u1 * N.y) |
| | >>> A.acc(N) - B.acc(N) |
| | (u1' - u2')*N.x + (-u1' + u2')*N.y |
| | |
| | """ |
| |
|
| | def __init__(self, name): |
| | """Initialization of a Point object. """ |
| | self.name = name |
| | self._pos_dict = {} |
| | self._vel_dict = {} |
| | self._acc_dict = {} |
| | self._pdlist = [self._pos_dict, self._vel_dict, self._acc_dict] |
| |
|
| | def __str__(self): |
| | return self.name |
| |
|
| | __repr__ = __str__ |
| |
|
| | def _check_point(self, other): |
| | if not isinstance(other, Point): |
| | raise TypeError('A Point must be supplied') |
| |
|
| | def _pdict_list(self, other, num): |
| | """Returns a list of points that gives the shortest path with respect |
| | to position, velocity, or acceleration from this point to the provided |
| | point. |
| | |
| | Parameters |
| | ========== |
| | other : Point |
| | A point that may be related to this point by position, velocity, or |
| | acceleration. |
| | num : integer |
| | 0 for searching the position tree, 1 for searching the velocity |
| | tree, and 2 for searching the acceleration tree. |
| | |
| | Returns |
| | ======= |
| | list of Points |
| | A sequence of points from self to other. |
| | |
| | Notes |
| | ===== |
| | |
| | It is not clear if num = 1 or num = 2 actually works because the keys |
| | to ``_vel_dict`` and ``_acc_dict`` are :class:`ReferenceFrame` objects |
| | which do not have the ``_pdlist`` attribute. |
| | |
| | """ |
| | outlist = [[self]] |
| | oldlist = [[]] |
| | while outlist != oldlist: |
| | oldlist = outlist.copy() |
| | for v in outlist: |
| | templist = v[-1]._pdlist[num].keys() |
| | for v2 in templist: |
| | if not v.__contains__(v2): |
| | littletemplist = v + [v2] |
| | if not outlist.__contains__(littletemplist): |
| | outlist.append(littletemplist) |
| | for v in oldlist: |
| | if v[-1] != other: |
| | outlist.remove(v) |
| | outlist.sort(key=len) |
| | if len(outlist) != 0: |
| | return outlist[0] |
| | raise ValueError('No Connecting Path found between ' + other.name + |
| | ' and ' + self.name) |
| |
|
| | def a1pt_theory(self, otherpoint, outframe, interframe): |
| | """Sets the acceleration of this point with the 1-point theory. |
| | |
| | The 1-point theory for point acceleration looks like this: |
| | |
| | ^N a^P = ^B a^P + ^N a^O + ^N alpha^B x r^OP + ^N omega^B x (^N omega^B |
| | x r^OP) + 2 ^N omega^B x ^B v^P |
| | |
| | where O is a point fixed in B, P is a point moving in B, and B is |
| | rotating in frame N. |
| | |
| | Parameters |
| | ========== |
| | |
| | otherpoint : Point |
| | The first point of the 1-point theory (O) |
| | outframe : ReferenceFrame |
| | The frame we want this point's acceleration defined in (N) |
| | fixedframe : ReferenceFrame |
| | The intermediate frame in this calculation (B) |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame |
| | >>> from sympy.physics.vector import dynamicsymbols |
| | >>> from sympy.physics.vector import init_vprinting |
| | >>> init_vprinting(pretty_print=False) |
| | >>> q = dynamicsymbols('q') |
| | >>> q2 = dynamicsymbols('q2') |
| | >>> qd = dynamicsymbols('q', 1) |
| | >>> q2d = dynamicsymbols('q2', 1) |
| | >>> N = ReferenceFrame('N') |
| | >>> B = ReferenceFrame('B') |
| | >>> B.set_ang_vel(N, 5 * B.y) |
| | >>> O = Point('O') |
| | >>> P = O.locatenew('P', q * B.x + q2 * B.y) |
| | >>> P.set_vel(B, qd * B.x + q2d * B.y) |
| | >>> O.set_vel(N, 0) |
| | >>> P.a1pt_theory(O, N, B) |
| | (-25*q + q'')*B.x + q2''*B.y - 10*q'*B.z |
| | |
| | """ |
| |
|
| | _check_frame(outframe) |
| | _check_frame(interframe) |
| | self._check_point(otherpoint) |
| | dist = self.pos_from(otherpoint) |
| | v = self.vel(interframe) |
| | a1 = otherpoint.acc(outframe) |
| | a2 = self.acc(interframe) |
| | omega = interframe.ang_vel_in(outframe) |
| | alpha = interframe.ang_acc_in(outframe) |
| | self.set_acc(outframe, a2 + 2 * (omega.cross(v)) + a1 + |
| | (alpha.cross(dist)) + (omega.cross(omega.cross(dist)))) |
| | return self.acc(outframe) |
| |
|
| | def a2pt_theory(self, otherpoint, outframe, fixedframe): |
| | """Sets the acceleration of this point with the 2-point theory. |
| | |
| | The 2-point theory for point acceleration looks like this: |
| | |
| | ^N a^P = ^N a^O + ^N alpha^B x r^OP + ^N omega^B x (^N omega^B x r^OP) |
| | |
| | where O and P are both points fixed in frame B, which is rotating in |
| | frame N. |
| | |
| | Parameters |
| | ========== |
| | |
| | otherpoint : Point |
| | The first point of the 2-point theory (O) |
| | outframe : ReferenceFrame |
| | The frame we want this point's acceleration defined in (N) |
| | fixedframe : ReferenceFrame |
| | The frame in which both points are fixed (B) |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols |
| | >>> from sympy.physics.vector import init_vprinting |
| | >>> init_vprinting(pretty_print=False) |
| | >>> q = dynamicsymbols('q') |
| | >>> qd = dynamicsymbols('q', 1) |
| | >>> N = ReferenceFrame('N') |
| | >>> B = N.orientnew('B', 'Axis', [q, N.z]) |
| | >>> O = Point('O') |
| | >>> P = O.locatenew('P', 10 * B.x) |
| | >>> O.set_vel(N, 5 * N.x) |
| | >>> P.a2pt_theory(O, N, B) |
| | - 10*q'**2*B.x + 10*q''*B.y |
| | |
| | """ |
| |
|
| | _check_frame(outframe) |
| | _check_frame(fixedframe) |
| | self._check_point(otherpoint) |
| | dist = self.pos_from(otherpoint) |
| | a = otherpoint.acc(outframe) |
| | omega = fixedframe.ang_vel_in(outframe) |
| | alpha = fixedframe.ang_acc_in(outframe) |
| | self.set_acc(outframe, a + (alpha.cross(dist)) + |
| | (omega.cross(omega.cross(dist)))) |
| | return self.acc(outframe) |
| |
|
| | def acc(self, frame): |
| | """The acceleration Vector of this Point in a ReferenceFrame. |
| | |
| | Parameters |
| | ========== |
| | |
| | frame : ReferenceFrame |
| | The frame in which the returned acceleration vector will be defined |
| | in. |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame |
| | >>> N = ReferenceFrame('N') |
| | >>> p1 = Point('p1') |
| | >>> p1.set_acc(N, 10 * N.x) |
| | >>> p1.acc(N) |
| | 10*N.x |
| | |
| | """ |
| |
|
| | _check_frame(frame) |
| | if not (frame in self._acc_dict): |
| | if self.vel(frame) != 0: |
| | return (self._vel_dict[frame]).dt(frame) |
| | else: |
| | return Vector(0) |
| | return self._acc_dict[frame] |
| |
|
| | def locatenew(self, name, value): |
| | """Creates a new point with a position defined from this point. |
| | |
| | Parameters |
| | ========== |
| | |
| | name : str |
| | The name for the new point |
| | value : Vector |
| | The position of the new point relative to this point |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import ReferenceFrame, Point |
| | >>> N = ReferenceFrame('N') |
| | >>> P1 = Point('P1') |
| | >>> P2 = P1.locatenew('P2', 10 * N.x) |
| | |
| | """ |
| |
|
| | if not isinstance(name, str): |
| | raise TypeError('Must supply a valid name') |
| | if value == 0: |
| | value = Vector(0) |
| | value = _check_vector(value) |
| | p = Point(name) |
| | p.set_pos(self, value) |
| | self.set_pos(p, -value) |
| | return p |
| |
|
| | def pos_from(self, otherpoint): |
| | """Returns a Vector distance between this Point and the other Point. |
| | |
| | Parameters |
| | ========== |
| | |
| | otherpoint : Point |
| | The otherpoint we are locating this one relative to |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame |
| | >>> N = ReferenceFrame('N') |
| | >>> p1 = Point('p1') |
| | >>> p2 = Point('p2') |
| | >>> p1.set_pos(p2, 10 * N.x) |
| | >>> p1.pos_from(p2) |
| | 10*N.x |
| | |
| | """ |
| |
|
| | outvec = Vector(0) |
| | plist = self._pdict_list(otherpoint, 0) |
| | for i in range(len(plist) - 1): |
| | outvec += plist[i]._pos_dict[plist[i + 1]] |
| | return outvec |
| |
|
| | def set_acc(self, frame, value): |
| | """Used to set the acceleration of this Point in a ReferenceFrame. |
| | |
| | Parameters |
| | ========== |
| | |
| | frame : ReferenceFrame |
| | The frame in which this point's acceleration is defined |
| | value : Vector |
| | The vector value of this point's acceleration in the frame |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame |
| | >>> N = ReferenceFrame('N') |
| | >>> p1 = Point('p1') |
| | >>> p1.set_acc(N, 10 * N.x) |
| | >>> p1.acc(N) |
| | 10*N.x |
| | |
| | """ |
| |
|
| | if value == 0: |
| | value = Vector(0) |
| | value = _check_vector(value) |
| | _check_frame(frame) |
| | self._acc_dict.update({frame: value}) |
| |
|
| | def set_pos(self, otherpoint, value): |
| | """Used to set the position of this point w.r.t. another point. |
| | |
| | Parameters |
| | ========== |
| | |
| | otherpoint : Point |
| | The other point which this point's location is defined relative to |
| | value : Vector |
| | The vector which defines the location of this point |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame |
| | >>> N = ReferenceFrame('N') |
| | >>> p1 = Point('p1') |
| | >>> p2 = Point('p2') |
| | >>> p1.set_pos(p2, 10 * N.x) |
| | >>> p1.pos_from(p2) |
| | 10*N.x |
| | |
| | """ |
| |
|
| | if value == 0: |
| | value = Vector(0) |
| | value = _check_vector(value) |
| | self._check_point(otherpoint) |
| | self._pos_dict.update({otherpoint: value}) |
| | otherpoint._pos_dict.update({self: -value}) |
| |
|
| | def set_vel(self, frame, value): |
| | """Sets the velocity Vector of this Point in a ReferenceFrame. |
| | |
| | Parameters |
| | ========== |
| | |
| | frame : ReferenceFrame |
| | The frame in which this point's velocity is defined |
| | value : Vector |
| | The vector value of this point's velocity in the frame |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame |
| | >>> N = ReferenceFrame('N') |
| | >>> p1 = Point('p1') |
| | >>> p1.set_vel(N, 10 * N.x) |
| | >>> p1.vel(N) |
| | 10*N.x |
| | |
| | """ |
| |
|
| | if value == 0: |
| | value = Vector(0) |
| | value = _check_vector(value) |
| | _check_frame(frame) |
| | self._vel_dict.update({frame: value}) |
| |
|
| | def v1pt_theory(self, otherpoint, outframe, interframe): |
| | """Sets the velocity of this point with the 1-point theory. |
| | |
| | The 1-point theory for point velocity looks like this: |
| | |
| | ^N v^P = ^B v^P + ^N v^O + ^N omega^B x r^OP |
| | |
| | where O is a point fixed in B, P is a point moving in B, and B is |
| | rotating in frame N. |
| | |
| | Parameters |
| | ========== |
| | |
| | otherpoint : Point |
| | The first point of the 1-point theory (O) |
| | outframe : ReferenceFrame |
| | The frame we want this point's velocity defined in (N) |
| | interframe : ReferenceFrame |
| | The intermediate frame in this calculation (B) |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame |
| | >>> from sympy.physics.vector import dynamicsymbols |
| | >>> from sympy.physics.vector import init_vprinting |
| | >>> init_vprinting(pretty_print=False) |
| | >>> q = dynamicsymbols('q') |
| | >>> q2 = dynamicsymbols('q2') |
| | >>> qd = dynamicsymbols('q', 1) |
| | >>> q2d = dynamicsymbols('q2', 1) |
| | >>> N = ReferenceFrame('N') |
| | >>> B = ReferenceFrame('B') |
| | >>> B.set_ang_vel(N, 5 * B.y) |
| | >>> O = Point('O') |
| | >>> P = O.locatenew('P', q * B.x + q2 * B.y) |
| | >>> P.set_vel(B, qd * B.x + q2d * B.y) |
| | >>> O.set_vel(N, 0) |
| | >>> P.v1pt_theory(O, N, B) |
| | q'*B.x + q2'*B.y - 5*q*B.z |
| | |
| | """ |
| |
|
| | _check_frame(outframe) |
| | _check_frame(interframe) |
| | self._check_point(otherpoint) |
| | dist = self.pos_from(otherpoint) |
| | v1 = self.vel(interframe) |
| | v2 = otherpoint.vel(outframe) |
| | omega = interframe.ang_vel_in(outframe) |
| | self.set_vel(outframe, v1 + v2 + (omega.cross(dist))) |
| | return self.vel(outframe) |
| |
|
| | def v2pt_theory(self, otherpoint, outframe, fixedframe): |
| | """Sets the velocity of this point with the 2-point theory. |
| | |
| | The 2-point theory for point velocity looks like this: |
| | |
| | ^N v^P = ^N v^O + ^N omega^B x r^OP |
| | |
| | where O and P are both points fixed in frame B, which is rotating in |
| | frame N. |
| | |
| | Parameters |
| | ========== |
| | |
| | otherpoint : Point |
| | The first point of the 2-point theory (O) |
| | outframe : ReferenceFrame |
| | The frame we want this point's velocity defined in (N) |
| | fixedframe : ReferenceFrame |
| | The frame in which both points are fixed (B) |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols |
| | >>> from sympy.physics.vector import init_vprinting |
| | >>> init_vprinting(pretty_print=False) |
| | >>> q = dynamicsymbols('q') |
| | >>> qd = dynamicsymbols('q', 1) |
| | >>> N = ReferenceFrame('N') |
| | >>> B = N.orientnew('B', 'Axis', [q, N.z]) |
| | >>> O = Point('O') |
| | >>> P = O.locatenew('P', 10 * B.x) |
| | >>> O.set_vel(N, 5 * N.x) |
| | >>> P.v2pt_theory(O, N, B) |
| | 5*N.x + 10*q'*B.y |
| | |
| | """ |
| |
|
| | _check_frame(outframe) |
| | _check_frame(fixedframe) |
| | self._check_point(otherpoint) |
| | dist = self.pos_from(otherpoint) |
| | v = otherpoint.vel(outframe) |
| | omega = fixedframe.ang_vel_in(outframe) |
| | self.set_vel(outframe, v + (omega.cross(dist))) |
| | return self.vel(outframe) |
| |
|
| | def vel(self, frame): |
| | """The velocity Vector of this Point in the ReferenceFrame. |
| | |
| | Parameters |
| | ========== |
| | |
| | frame : ReferenceFrame |
| | The frame in which the returned velocity vector will be defined in |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols |
| | >>> N = ReferenceFrame('N') |
| | >>> p1 = Point('p1') |
| | >>> p1.set_vel(N, 10 * N.x) |
| | >>> p1.vel(N) |
| | 10*N.x |
| | |
| | Velocities will be automatically calculated if possible, otherwise a |
| | ``ValueError`` will be returned. If it is possible to calculate |
| | multiple different velocities from the relative points, the points |
| | defined most directly relative to this point will be used. In the case |
| | of inconsistent relative positions of points, incorrect velocities may |
| | be returned. It is up to the user to define prior relative positions |
| | and velocities of points in a self-consistent way. |
| | |
| | >>> p = Point('p') |
| | >>> q = dynamicsymbols('q') |
| | >>> p.set_vel(N, 10 * N.x) |
| | >>> p2 = Point('p2') |
| | >>> p2.set_pos(p, q*N.x) |
| | >>> p2.vel(N) |
| | (Derivative(q(t), t) + 10)*N.x |
| | |
| | """ |
| |
|
| | _check_frame(frame) |
| | if not (frame in self._vel_dict): |
| | valid_neighbor_found = False |
| | is_cyclic = False |
| | visited = [] |
| | queue = [self] |
| | candidate_neighbor = [] |
| | while queue: |
| | node = queue.pop(0) |
| | if node not in visited: |
| | visited.append(node) |
| | for neighbor, neighbor_pos in node._pos_dict.items(): |
| | if neighbor in visited: |
| | continue |
| | try: |
| | |
| | neighbor_pos.express(frame) |
| | except ValueError: |
| | continue |
| | if neighbor in queue: |
| | is_cyclic = True |
| | try: |
| | |
| | neighbor_velocity = neighbor._vel_dict[frame] |
| | except KeyError: |
| | queue.append(neighbor) |
| | continue |
| | candidate_neighbor.append(neighbor) |
| | if not valid_neighbor_found: |
| | self.set_vel(frame, self.pos_from(neighbor).dt(frame) + neighbor_velocity) |
| | valid_neighbor_found = True |
| | if is_cyclic: |
| | warn(filldedent(""" |
| | Kinematic loops are defined among the positions of points. This |
| | is likely not desired and may cause errors in your calculations. |
| | """)) |
| | if len(candidate_neighbor) > 1: |
| | warn(filldedent(f""" |
| | Velocity of {self.name} automatically calculated based on point |
| | {candidate_neighbor[0].name} but it is also possible from |
| | points(s): {str(candidate_neighbor[1:])}. Velocities from these |
| | points are not necessarily the same. This may cause errors in |
| | your calculations.""")) |
| | if valid_neighbor_found: |
| | return self._vel_dict[frame] |
| | else: |
| | raise ValueError(filldedent(f""" |
| | Velocity of point {self.name} has not been defined in |
| | ReferenceFrame {frame.name}.""")) |
| |
|
| | return self._vel_dict[frame] |
| |
|
| | def partial_velocity(self, frame, *gen_speeds): |
| | """Returns the partial velocities of the linear velocity vector of this |
| | point in the given frame with respect to one or more provided |
| | generalized speeds. |
| | |
| | Parameters |
| | ========== |
| | frame : ReferenceFrame |
| | The frame with which the velocity is defined in. |
| | gen_speeds : functions of time |
| | The generalized speeds. |
| | |
| | Returns |
| | ======= |
| | partial_velocities : tuple of Vector |
| | The partial velocity vectors corresponding to the provided |
| | generalized speeds. |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy.physics.vector import ReferenceFrame, Point |
| | >>> from sympy.physics.vector import dynamicsymbols |
| | >>> N = ReferenceFrame('N') |
| | >>> A = ReferenceFrame('A') |
| | >>> p = Point('p') |
| | >>> u1, u2 = dynamicsymbols('u1, u2') |
| | >>> p.set_vel(N, u1 * N.x + u2 * A.y) |
| | >>> p.partial_velocity(N, u1) |
| | N.x |
| | >>> p.partial_velocity(N, u1, u2) |
| | (N.x, A.y) |
| | |
| | """ |
| |
|
| | from sympy.physics.vector.functions import partial_velocity |
| |
|
| | vel = self.vel(frame) |
| | partials = partial_velocity([vel], gen_speeds, frame)[0] |
| |
|
| | if len(partials) == 1: |
| | return partials[0] |
| | else: |
| | return tuple(partials) |
| |
|
