The analysis of the efficiency of algorithms resulting from Kane's Equation for serial and parallel computation of mass matrix is examined. The algorithms resulting from Kane's equation and Modified Kane's equations are detailed. An analysis was made of two classes of algorithms for computation of mass matrix: the Newton-Euler based algorithms and the Composite rigid body algorithms. An analysis was also made of the efficiency of different algorithms for serial and parallel computations. Conclusions are drawn and presented

Fijany, Amir

English

NASA Technical Reports Server

-/.;.f,%.----
.J
I;
N91-22320
Serial and Parallel Computation of Kane's
Equations for Multibody Dynamics
by
Amir Fijany
Jet Propulsion Laboratory, Cafifornia Institute of Technology
JSi
PRr;ICF-'DING PAGE BLANK NOT FILMED
https://ntrs.nasa.gov/search.jsp?R=19910013007 2020-03-19T17:52:38+00:00Z
Objective:
Analysis of the Efficiency of Algorithms resulting from
Kane's Equation for Serial and Parallel Computation of Mass
Matrix.
Overview:
* Algorithms resulting from Kane's Equation and Modified
Kane's Equation.
* Analysis of two Classes of Algorithms for Computation of
Mass Matrix: The Newton-Euler Based Algorithms and the
Composite Rigid-Body Algorithms.
* Analysis of the Efficiency of Different Algorithms for
Serial and Parallel Computation.
* Conclusion
Multibody Dynamics
Case Study: Rigid Multibody as Specialized to a Single Chain
Robot Manipulator.
00
Multibody Dynamics: Solution for Q from
AQ=_T-b=_ (i)
A: nxn Symmetric Positive definite Mass Matrix
eo
Q: nxl Vector of Generalized Accelerations
_" nxl Vector of Applied Forces/Torques
b: nxl Vector of nonlinear Terms (Bias vector)
iF" nxl Vector of Applied Inertia Forces/Torques
The O(n 3) Algorithms for Multibody Dynamics:
1) Computation of b and
2) Computation of Mass Matrix A.
3) Solution of Eq. (1) by Inversion of A.
Kane's Equation is widely used for Computation of Mass
Matrix.
Kane's Method: Notation
Q: nxl Vector of Generalized Coordinates
U: nxl Vector of Generalized Speeds
n
Choice of U: U : Y A (_ + B
1 1, lj jj=l
Angular and Linear Velocity of Body (Link) i
n
--_ L --i(]) J -i(t)
J=l
n
V = _ V U +V
--i --i(j) j --i(t)
j=l
: Angular Velocity of Body i
i
: jth Partial Angular Velocity of Body i
i(j)
: Angular Velocity of Remainder Terms
l(t)
V : Linear Velocity of Center
i
of Mass of Body i
V
i(j)
: jth Partial Linear Velocity of Center of Mass
of Body i
m
V
l(t)
: Linear Velocity of Center of Mass of Body i
Remainder Terms
Kane's Method: Notation
Partial Angular and Linear Momentum
N = I_
-t(j) =l-[ (j)
F :mY
--t(J) t-i (J)
N : jth Partial Angular Momentum of Body i
i(j)
F : jth Partial Linear Momentum of Body i
1(j)
Kane's Equation for Computation of Mass Matrix
The element a of Mass Matrix A is Computed as
lj
n
a i = V .F + o_ .Nj --k(i) --k(j) --k(i) --k(J)
k=j
n
= V .mY +_ .I_
--k(1) k--k (J) --k(i) --k--k (j)
k=J
Kane's Equation: Analysis of General Case
For Analysis of the General Case, We Set U = Q.
i z
= Z and _ = 0
--i(j) --j -i(t)
i
__. = _ z.q
I j lj=l
V = (_Z.x P ) and V
--i(j) j --i', j --i (t)
= 0
i
V = (Zx P )Q
-i -j -i', j j
j=l
N = I_ = IZ
--i (j) --i-i (j) --i--j
F = m.(_Z.x P )
-i(j) _ j -i*,j
Kane's Equation can be written as
n
al = t,_ (Z x P ).m (Z x P ) + Z .I Zj --i --k _, i k --j --k *, j --i :k--j
k=j
AN O(n 3) Algorithm Based on Kane's Equation
For i = I, 2, ..., n
For j = i, i+l, ..., n
n
ai = I (Z x P ).m (Z x P ) + Z .I Z
j --i --k m, i k --j --k _, j --i =k--j
k=j
This Algorithm is Designated as Original Kane's Equation (OKE)
Algorithm.
Modified Kane's Equation
n
ai =J
k=J
(Z x P ).m (Z x P ) + Z .I Z
--j --k _, j k --i --k m, i --j --k-i
n
=_ Z.
-j
k=j
x (mZxP(-Pk-,j k-i --k"i
9
) +Z.IZ
-j =k--i
n
= _. z .((-Pk.,x
-] j
k=j
(mZx P ) +
k--i --k* i
IZ)
=k--i
AN O(n 2) Algorithm Based on Kane's Equation
For i = I, 2, ..., n
For j = i, i+l, ..., n
P =P +p
--j, i --j-l, i -j, j-1
P =P +S
--j_, i --j,i --j
N = IZ
--j (i) --j--i
F =m(ZxP )
-J(1) J-i -j" i
For j = n, n-l, ..., i
f =F +f
--j(1) --j(1) --j+l(i)
n =N +SxF +n +P xf
--j(i) --j(i) --j --j(i) --]+l (i) --j+l, j --j+l (i)
a =Z.n
ij --j -j (i)
This Algorithm is Designated as Variant of Kane's Equation (VKE)
Algorithm.
Algorithms for Computation of Mass Matrix
J ,
A -P (1)
all = all =/"i (2)
For the conditions given as
Qi = 1 and Qj = Qj_:i = 0 For j = 1, 2, ..., n (3)
Two physical interpretations of Eqs. (2) & (3) lead to two
classes of algorithms for computation of mass matrix:
1. The Newton-Euler Based (N-E B) Algorithms.
Underlying Physical Concept: Propagation of acceleration
among rigidly connected bodies.
The Variant of Kane's Equation (VKE) Algorithm belongs to
this class.
2. The Composite Rigid-Body (CRB) Algorithms.
Underlying physical Concept: Propagation of force among
rigidly connected bodies.
190
Algorithms for Computation of Mass Matrix
Clearly, the two physical interpretations are the same.
We have shown that the algorithms of the two classes can be
transformed to one another.
From an algorithmic point of view, the main difference
between the algorithms of the two classes is the presence of
a two-dimensional recursion in Composite Rigid-Body
Algorithms.
The main issue is to determine the best algorithm(s) for
serial and parallel computation.
The Original Kane's Equation Algorithm is the least efficient
since its computational complexity is of O(n3).
The computational complexity of both the Newton-Euler
Based Algorithms and Composite Rigid-Body Algorithms is of
O(n2). However, the Composite Rigid-Body Algorithms, in
general, are more efficient.
Algorithms for Computation of Mass Matrix
There are four major redundancies in the Original
Newton-Euler Based Algorithm which can be removed by:
1) Optimizing the Newton-Euler Formulation for the
conditions given in Eq. (3),
2) Using a variant of Newton-Euler Formulation,
3) Choosing a better coordinate frame for projection of
equations.
4) Introducing a two-dimensional recursion in the
computation which transforms it to an equivalent
Composite Rigid-Body Algorithm.
192
A Variant of Newton-Euler Based Algorithm
Step 1:
For j = I, 2, ..., n
For i = j, j+l, ..., n
_(i,j) = _Z(j)
0
¢(i,j) = V(i-I,j) + __(i,j)xP(i,i-l)
F(i+l,i,j) = m(i)V(i,j) +__(i,j)xh(i)
N(i+l,i,j) = k(i)__(i,j)
Step 2:
For i = n, n-l, ..., j
F(n+l,n+l,j) = N(n+l,n+l,j) = 0
F(n+l,i,j) = F(i+l,i,j) + F(n+l,i+l,j)
N(n+l,i,j) = N(i+l,i,j) + N(n+l,i+l,j) +
P(i+l,i)xF(n+l,i+l,j)
a.. = Z(i).N(n+l,i+l,j)
jl - --
This algorithm results from removing the first two redundancies
of the 0 N-E B Algorithm. It is clearly equivalent to the 0(n 2)
algorithm resulting from the Kane's Equation or the Variant of
Kane's Equation (VKA) Algorithm. I_3
m(i) Mass of body i.
h(i)
k(i)
z(i)
First moment of mass of body i about point 0..
1
Second moment of mass of body i about point 0..
1
Axis of joint i
P(i,j) Position vector from point j to point i.
_(i,j) Angular acceleration of body i resulting from the
unit acceleration of joint j.
V(i,j) Linear acceleration of body i (point 0.)
1
resulting from the unit acceleration of joint j.
F(k+l,i,j) Force exerted on point O. due to the acceleration
i
of bodies i through k, i.e., the bodies contained
between points Oi and Ok+l, resulting from the
unit acceleration of joint j.
N(k+l,i,j) Moment exerted on point O. due to the acceleration
1
of body i through k, resulting from the unit
acceleration of joint j.
A Variant of Composite Rigid-Body Algorithm
Step 1 :
For i = n, n-l, ..., I
M(i) = m(i) + M(i+l)
H(i) = h(i) + H(i+l) + M(i+l)P(i+l,i)
A
K(i) = k(i) + K(i+l) -M(i+l)P(i+l,i)P(i+l,i) -
P(i+l,i)H(i+l) - H(i+l)P(i+l,i)
f(i) = Z(i)xH(i)
n(i) = K(i)Z(i)
a = Z(i).n(i)
Ii -- --
Step 2:
For j = i-l, i-2, ..., I
f(j) = £(j+I)
_n(j) = __n(j+1) +__P(j+l,j)xf(j+1)
a = Z(j)._n(j)jl
M(i)
H(i)
K(i)
Mass of composite rigid-body i composed of bodies i
through n.
First moment of mass of composite riEid-body i about
point 0..
i
Second moment of mass of composite rigid-body i
about point 0..
1
Comparison of Serial Efficiency of Different
Algorithms
In order to study the relative efficiency of the algorithms,
the optimal choice of coordinate frame(s) for projection of
the Equations should be carefully analyzed.
For the Variant of Newton-Euler Algorithm, projection of all
equations onto any fixed frame leads to maximum
computational efficiency; It requires O(n) transformations.
Projection onto the body frame leads to copmputational
inefficiency; it requires O(n 2) transformations!
For the Variant of Composite Rigid-Body Algorithm,
projection of Step 1 onto body frame and Step 2 onto any
fixed frame leads to maximum computational efficiency; It
requires O(n) transformations.
Projection of both steps onto the body frame leads to
copmputational inefficiency; it requires O(n 2)
transformations!
Comparison of Serial Efficiency of Different
Algorithms
Redundancy
p
® ® ® ®
V C R-B 0 C R-B V N-E B 0 N-E B
®
OKA
Serial Efficiency
OKEA: Original Kane's Equation Algorithm.
0 N-E B: Original Newton-Euler Based Algorithm.
V N-E B: Variant of Newton-Euler Based Algorithm.
0 C R-B: Original Composite Rigid-Body Algorithm.
V C R-B: Variant of Composite Rigid-Body Algorithm.
Algorithm
VN-EB
VCR-B
General
Mul. Add.
(39/2)n2+ 19n2+
(195/2)n-95 55n-66
2(9/2)n + 4n2+
(231/2)n-181 88n-137
n=6
Mul. Add. Total
1192 948 2140
644 535 1179
all
I
a21
a31
aoo
i
I
a32 a33
i QQm
1
I
!
i 1
anl an2 an3
an-1 n-1
I
an n-1 ann
(a)
all a12
"\ I
a13
a23
a33
an n-1 aln
a2n
i
i
a33
I 1
• !
t
• !
• °
an-ln-1 an-ln
an n
(b)
Computational Structure of and Data-Dependency in Algorithms for
Mass Matrix
a) The Newton-Euler Based Algorithms
b) The Composite Rigid-Body Algorithms
Algorithmic Choice for Parallel Computation of
Mass Matrix
Parallelism in Computation of Mass Matrix: Time and
Processors Bouds
We have shown that the time lower bound in computation of
mass matrix is of O(log2n ) and can be achieved by using O(n 2)
processors.
The Original Kane's Equation Algorithm might seem very
suitable for parallel computation since all elements of the
mass matrix can be computed totally in parallel.
The computation of each element of mass matrix can be
performed in O(log2n ) steps by using O (n) processors. Hence,
in order compute all the elements in parallel and achieve the
time lower bound of O(log2n), O(n 3) processors are required!
Using both the Newton-Euler Based Algorithms and the
Composite Rigid-Body Algorithms, the mass matrix can be
computed in O(log2n ) steps with only O(n 2) processors.
200
Algorithmic Choice for Parallel Computation of
Mass Matrix
The Newton-Euler Based Algorithms are more suitable for
parallel computation due to their regular computational
structure and a lesser degree of data-dependency in their
computation.
1) They provide a high degree of coarse grain parallelism:
The columns of the mass matrix can be computed in
parallel.
2) They are more regular and have a finer grain:
A higher degree of parallelism in computation of the
elements of each column can be exploited
3) Their parallel computation on a two-dimensional
processor array requires simpler communication and
synchronization mechanisms.
Choice of Coordinate Frame for Parallel Computation on a
two-dimensional processor array:
For the Variant of Newton-Euler Based Algorithm it is more
efficient to project the equations of onto the End-effector
(Body n) frame while for the Variant of Composite Rigid-Body
Algorithm it is more efficient to project the equations onto
the base frame!
Conclusion
* For recursive serial computation, the Variant of Composite
Rigid-Body Algorithm is significantly more efficient than
the Variant of Newton-Euler and the Variant of Kane's
Equation Algorithms.
* For parallel computation with O(n2) processors, i.e.,
maximum exploitation of parallelism, the Variant of
Newton-Euler and the Variant of Kane's Equation Algorithms
are not only significantly more efficient than the Variant of
Composite Rigid-Body Algorithm but they also require
much simpler architectural features.
* For parallel computation with O(n) processors, i.e., limited
exploitation of parallelism, the Variant of Composite
Rigid-Body Algorithm is more efficient than the Variant of
Newton-Euler and the Variant of Kane's Equation Algorithms
202
Comparison of Two Classes of Serial and Parallel
Algorithms for Computation of Mass Matrix
Algorithm
VCR-B
SA
VN-EB
VCR-B
PA
VN-EB
VCR-B
PPA
VN-EB
Computation Cost
General
2
((9/2)m+4a))n +
((231/2)m+SSa))n-
(181m+137a)
n=6
644m+535a
2
((39/2)m+19a)n +
((195/2)m+55a)n-
(95m+66a]
l192m+948a
(48m+63a)[log2n]+
(100m+65a)
244m+254a
(33m+S3a)[log2n]+
(109m+89a)
208m+IS8a
(9m+Sa)n+(48m+63a)[log2n]+
(58m+24a)
256m+261a
(39m+38a)n+(27m+ISa)[log2n]+ 340m+280a
(25m-2a)
SP
2.40
2.98
2.32
I. 90
Proc.
1
1
n(n+l)/2
n(n+l)/2
n
n
SA: Serial Algorithm.
PA: Parallel Algorithm with 0(n 2) processors.
PPA: Parallel Algorithm with O(n) processors.
Parallel VNEB algorithm
Step 1:
I) Parallel compute R(O+I,O) by all processors of Row j.
For j = I, 2 ,..., n
For i = I, 2, ..., j
PRji : R(j+I,j)
2) Parallel compute R(n+l,j) by processors of Column i.
For i = I, 2, ..., n
For j = i, i+l, ..., n
= 1 step 1 until [log2(n+l-i) ], DoFor
R(j+2W, j) = R(n+l,j)
j+2n>j+2n-_zn+l
R(j+2 n,j) = R(n+l,j) = R(n+l,j+2n-l)R(j+2 _-i,j)
j+2Wmn+l>j+2 TM
R(j+2 n,j) = R(j+2 n,j+2n-l)R(j+2 n-l,j)
n+l>j+2n>j+2 n-1
EndDo
3) Shift R(n+l,j+l) by processors of Row j+l to the processors of
Row j.
For j = I, 2, ..., n
For i = 1, Z, ..., j
PR : R(n+l, j+l)
Jl
with R(n+l,n+l) = U (Unit Matrix)
204
n+Ip + n+lH4) Parallel compute n+IZ(j), (j l, j), and (j) by all
processors of Row j.
For j = i, 2 ,..., n
For i = I, 2, ..., j
n+l Za) PR : (j) = R(n+l,J)JZ(J)
ji
with ]Z(j) = [0 0 I] t
n+Ip =b) PR : (j+l,j) R(n+I,j+I)J+IP(j+I,J)
31
c) PR
]i
n+1 , S(j ): S(j) = R(n+l j+l) j+1 "
n+lH )n+1Sd) PR : (j) = M(j (j)
]I
Step 2:
I) Parallel compute P(j+l,i) and _(j,i) by processors of Column i.
For i = I, 2 .... , n
For j = i, i+l, ..., n
For W = I step I until [log2(n+l-i) ], Do
_(j+2 _,i) = _(j+2 _-I,i) = Z(i)
P(j+2 n,j) = P(j+l,i)
j+2n>j+2n-1__n+l
P(j+2 n, j) = P(j+I, i) = P(j+2 _, j+2n-1)+p(j+2 TM, j)
j+2n-_n+ 1>j+2 TM
P(j+2 n,j) = p(j+2 n,j+2 n-1)+P(j+2 n-l,j)
n+l>j+2n>j+2 TM
End_Do
2) Parallel compute V(j,i), F(j+l,j,i), and N(j+l,j,i) by
processors of Column i.
For i = I, 2, ..., n
For j = i, i+l, ...n
a) PRjI: V(j,i) = _(j,i)xP(j+l,i) = Z(i)xP(j+l,i)
b) PRji: F(j+l,j,i) = m(j,i)xH(j)+M(j)V(j,i)
H(j)xV(j, i)
Step 3:
I) Parallel compute F(n+l,j,i) processors of Column i.
For i = I, 2, ..., n
For j = i, i+l, ..., n
For _ = 1 step 1 until [loga(n+l-j)], Do
F(j+2_,j,i) = F(n+l,j,i)
j+2_>j+2_-1mn+l
F(j+2_,j,i) = F(n+l,j,i) = F(j+2_,j+2_-I,i)+F(j+2_-I j,i)
j+2W>n+l>j+2 TM
F(j+2_,j,i) = F(j+2_ j+2_-I i)+F(j+2_-1,j,i )
n+l>j+2_>j+2 TM
End Do
2) Shift F(n+l,j+l,i) by processors of Row j+l to processors of
Row j.
For j = I, 2, .... n
For i = I, 2, ..., j
PR : F(n+l, j+l, i)
jl
3) Parallel compute N(n+l,j,i) by processors of Column i.
For i = I, 2, ..., n
For j = i, i+l, ..., n
a) PR : N(j+l,j,i) = N(j+l,j,i)+P(j+l,j)xF(n+l,j+l,i)
jl
b) For _ = 1 step 1 until __[l°g2(n+l-J) ], Do
N(j+2 _,j,i) = N(n+l,j,i)
j+Z_>j+2_-Imn+ 1
N(j+Zn, j,i) = N(n+l,j,i) = N(n+l,j+2n-l,i)+N(j+2n-l,j,i)
j+Zn_n+l>j+2 n-i
N(j+2W, j,i) = N(j+2D j+2W-l,i)+N(j+2W-l,j,i )
n+l>j+2W>j+2 _-i
End Do
2) Parallel compute a by PR .
ji jl
For i = I, 2, ..., n
For j = i, i+l, ...n
PR : a = Z{j).N(n+l,j,i)jl jl
208
(209
Algorithm-To-Architecture Mapping
Determination of an Algorithmically-Speciaslized Parallel
Architecture for Efficient Implementation of the Algorithm.
1) Processors Interconnection and Communication
Complexity
For perfect mapping:
a) The required interconnection among processors of each
column is Shuffle Exchange augmented with Nearest-Neighbor
(SENN).
b) The required interconnection among processors of each
row is Nearest-Neighbor.
The perfect mapping leads to a communication complexity of
O(log2n ). Mapping on an array with nearest-neighbor
interconnection leads to the communication complexity of
O(n).
2) Synchronization Mechanism
Exploitation of parallelism at two computational levels:
a) Coarse grain parallelism in computing columns of mass
matrix, and
b) Fine grain parallelism in computing the elements of each
column.
Global Clock-Based Synchronization Mechanism (similar to
Systolic Array) for processors of each column, and Local Data
Driven (similar to Wavefront Array) for processor of each
row.
2)0


Serial and parallel computation of Kane's equations for multibody dynamics

Abstract

Similar works

Full text

Available Versions

NASA Technical Reports Server