]> A Practical Guide to Tensegrity Design: 3 General Tensegrity Structures

Chapter 3

General Tensegrity Structures

3.1 General Programming Problem

3.1.1 General Programming Problem: Introduction

An inventory of the components of a tensegrity structure can start out with sub-systems called hubs. These hubs are the areas in the tensegrity where members meet and are fastened together. Members are interactions between pairs of hubs and can be further classified as either struts (compression members which keep pairs of hubs apart) or tendons (tensile members which pull pairs of hubs together). There may be constraints relating to member lengths, symmetry and geometrical determinacy.

In initial design stages, it may be easier to treat the hubs as undifferentiated systems where members all meet at a point. This was the strategy used in Chapter 2. In many real applications though, tendons are attached to the hub at multiple points. In these cases, the design either has to formally model the hub as composed of multiple attachment points or adopt some ad hoc way of relating the model's geometry to that of the physical structure. When the hub is formally modeled as a collection of separate attachment points, one or more vectors indicate how these attachment points are positioned with respect to each other and relative to a single basic point associated with the hub. Additional constraints are necessary to determine each vector's length and direction.

As Chapter 2 showed, an effective tensegrity design strategy involves minimizing or maximizing the lengths of one set of members while the other members are constrained to have various fixed lengths. So, the general problem is set out as:

$minimize o≡ w‾1 ⁢ l12 +⋅⋅⋅+ w‾ no ⁢ lno2 P1, …,P nh, V1, …,V nv subject to Member constraints: ± l‾ no+1 2 ≥ ±l no+1 2 ⋅⋅⋅ ± l‾ nm2 ≥ ±l nm2 Symmetry constraints: s‾1 = s1 ⋅⋅⋅ ⋅⋅⋅ s‾ ns= sns ⋅⋅⋅ Point constraints: d‾1= W‾1 ⋅Pd1 ⋅⋅⋅ d‾ nd= W‾nd ⋅ Pdnd Vector constraints: c‾1= c1 ⋅⋅⋅ ⋅⋅⋅ c‾ nc= cnc ⋅⋅⋅$

where:

 $nh= number of hubs =number of basic points$ $nv= number of vectors$ $no= number of members in the objective function$ $nm= number of members in the model$ $no~= nm-no =number of constrained members$ $ns= number of symmetry constraints$ $nd= number of point constraints$ $nc= number of vector constraints$

The expression $P1, …,P nh, V1, …,V nv$ appearing under "minimize" indicates that the coordinate values of the basic points and vectors are the control variables of the minimization problem. These are the values which are changed (in accordance with the constraints) to find a minimum value for $o$.

In the objective function, $w‾ io$ is a positive constant value if the corresponding member is a tendon and negative if the member is a strut where $io∈ 1… no$.

In the objective function and member constraints, $lim$ stands for the length of member $im$ where $im∈ 1… nm$.

In the member constraints, $l‾ io~$ is a positive constant value. "+" precedes $l‾ io~ 2$ and $l io~ 2$ if the corresponding member is a tendon, and "-" precedes them if the member is a strut where $io~ ∈ no+1 … nm$.

In the other constraints, $sis ⋅⋅⋅$ and $cic ⋅⋅⋅$ are functions of the coordinate values, and $s‾ is$, $d‾ id$ and $c‾ ic$ are constant values where $is∈ 1… ns$, $id∈ 1… nd$ and $ic∈ 1… nc$.

In the point constraints, $W‾ id$ is a triplet of fixed values which is applied to $Pdid$ using a dot product where for any value of $id$, $did ∈ 1… nh$.

So, the examination of this problem is divided into five sections: the objective function, the member constraints, the symmetry constraints, the point constraints and the vector constraints.

3.1.2 General Programming Problem: Objective Function

In the basic tensegrity structures of Chapter 2, the objective functions consisted of the second power of the length of one member. If this member was a tendon, the quantity was minimized. If this member was a strut, the quantity was maximized. For these simple structures, including just one instance of a symmetrical class of members in the objective function worked fine, but, for more complex structures, this procedure leads to a lopsided structure having one tendon much shorter than its comparable companions. So, in complex structures, the lengths of several instances of non-symmetrical classes of members are minimized (for tendons) or maximized (for struts).

How can this be done? A mathematical programming problem can't have more than one objective function; so, a different objective function for the length of each non-symmetrical instance is not a possibility. What can be done is minimize a weighted sum of the second powers of these lengths. Positive weights are used for tendon lengths. If a strut is included in the objective function, it is included with a negative weight since minimizing the additive inverse of a quantity is the same as maximizing the quantity. This approach results in a valid tensegrity since, in the final solution, each of the member lengths is minimized (for tendons) or maximized (for struts) with respect to the others. If this weren't the case, the length of one member could be reduced (for a tendon) or increased (for a strut) while maintaining the lengths of the others. This would result in a weighted sum less than the minimum which cannot be if the problem was solved correctly. So, the general form for the objective function is:

$o≡ w‾1 ⁢ l12 +⋅⋅⋅+ w‾ no ⁢ lno2$

Besides allowing tendons to be minimized and struts to be maximized in the same objective function, the weights give the designer control over the relative lengths of the members which appear in the objective function. The weights can be chosen as desired subject only to the requirement that the weight for a tendon must be positive (since tendon lengths are minimized) and the weight for a strut must be negative (since strut lengths are maximized). In Section 7.2.6 it is shown that any valid tensegrity configuration can be viewed as the solution to a mathematical programming problem of this form with an appropriate selection of weights. This fact gives this weighted-sum approach complete generality as a tool for tensegrity design.

3.1.3 General Programming Problem: Member Constraints

The member lengths which don't appear in the objective function appear in the constraints. The constraint function is the second power of member length in the case of a tendon and minus the second power of length in the case of a strut. This value is constrained to be less than or equal to $± l‾ io~ 2$ where again the member type determines the sign used.

In the general model, these constraints are inequalities since tendons are members which can pull points together but can't push them apart, and struts are members which can push points apart but can't pull points together. Practically, the strut may be made of materials which are capable of sustaining a very substantial tensile load (though certainly the struts may be fabricated so they can stand no tensile load at all), but in a final design, they should not be sustaining such a load since they are not designed for this. So, even for struts, an inequality is called for in the constraints.

Since, for uniformity, the equations are organized so that the constrained value is always less than or equal to some fixed value, the second power of strut lengths and the corresponding $l‾ io~ 2$ constants are negated in the strut constraint equations. In practice (see Section 3.2), all the constraints are treated as equalities.

3.1.4 General Programming Problem: Symmetry Constraints

In the simple tensegrities examined in Chapter 2, symmetry constraints are mentioned, but are dealt with implicitly by making geometrical assumptions (Sections 2.2.2 and 2.4) or in the mathematical programming problems by doing substitutions (Sections 2.2.3 and 2.3). In the latter case, the simplicity of the symmetry transformations and the coordinate systems used allows the coordinates of one point to be expressed as a simple signed permutation of the coordinates of another point.

In the general problem, the geometry is fairly general and implements no assumptions about symmetry. In addition, the very real possibility exists that some symmetry constraints cannot be accounted for by simple coordinate substitutions since, in general, a symmetry-transformed coordinate is a linear combination of all three coordinates of another point. However, for most of the models discussed in this book, though some of them are rather complex, the symmetry constraints are of the simpler type so that they do not appear in the programming problem explicitly, but only appear implicitly as signed coordinate permutations. This is because most of the models have octahedral symmetries. When other symmetries are used, for example the icosahedral symmetry of the model discussed in Section 5.4, symmetry constraints may need to be introduced explicitly. This introduction creates no real mathematical problems other than slowing down the computations due to the larger system.

$s‾ is$ is always 0, but it is convenient to keep the label for symbolic manipulations later.

3.1.5 General Programming Problem: Point Constraints

This type of constraint appeared explicitly as the last two constraints in the Cartesian-coordinate model for the t-prism in Section 2.2.3. It appeared implicitly in the cylindrical-coordinate model of the t-prism in Section 2.2.2 where the $z$ coordinates of points $A$, $B$ and $C$ were fixed at 0. In general, for cylindrical (e.g. masts) or truncated (e.g. domes) structures point constraints need to be introduced to make the mathematical model of the structure determinant. For structures with spherical symmetries, the member, symmetry and vector constraints are sufficient for determining the structure.

Point constraints are linear equalities restricting a point to lie in a specific plane. In Cartesian coordinates, the format of a point constraint is a dot product of a point with a triplet of fixed values. The dot product is constrained to be a particular value. The triplet of fixed values is referred to here as the determining vector of the point constraint, and the point lies in a plane orthogonal to this vector when it conforms to the constraint. Point constraints don't seem to be necessary when using conjugate-direction methods to solve a mathematical programming problem, but can be necessary when using Newton's method to improve a solution's accuracy.

3.1.6 General Programming Problem: Vector Constraints

Vector constraints fill in the details about the geometry of complex hubs. The use of these constraints, and the list of vectors they affect, $V1, …,V nv$, represents a move away from the initial gross analysis of a tensegrity structure, where the details of strut-tendon connections are omitted for simplicity's sake, to a more detailed analysis of the structure, where the struts and tendons are no longer assumed to meet at a point. This includes situations where a tendon is attached to a point away from the ends of the strut, i.e. between the ends somewhere, or off the centerline of the strut, or both. A vector is a difference between two points and is necessary to model the offset from the strut end point to the point where the tendon is attached.

In general, the tendon attachment points are still clustered in two areas on the strut in proximity to the locations which were modeled as simple strut end points in the gross analysis. Each cluster of points is defined with respect to the basic point which corresponds to the hub they represent, or in some cases they are defined with respect to a convex combination of the basic points corresponding to the two hubs a strut connects. Especially in the latter case, the center of the hub does not necessarily coincide with the location of the corresponding basic point.

As an example of what vector constraints are like, consider the case where, instead of assuming the tendon is connected on the center line of the strut, it is more realistically assumed that the tendon connects to the surface of the strut and thus the attachment point falls off the center line of the strut. For this example, the strut is assumed to be a simple cylinder.

The first step is to introduce a single vector which represents the offset to the tendon attachment point from a reference point lying on the center line of the strut. This reference point may be one of the basic points corresponding to the two hubs the strut connects or perhaps a point on a line through the basic points of those two hubs. A vector constraint is then introduced which indicates how far from the reference point the tendon is to be connected. In this case, that distance would correspond to the radius of the strut. This constraint would restrict the tendon's attachment point to lie on a sphere about the point. A second constraint is then introduced to restrict the vector to be orthogonal to the center line of the strut. The attachment point is thus constrained to lie on a plane through the reference point and orthogonal to the strut's center line. This second constraint makes sure the tendon is attached to the surface of the strut rather than at an interior point.

An example using vector constraints appears in Section 7.3.6.

3.2 Solving the Problem

In this section, two methods for solving this general problem are described. The problem can be characterized as a mathematical programming problem in which both the objective function and the constraints are non-linear in the control variables. The constraint region is not convex1, so the simpler algorithms admissible in that case cannot be used. The non-linearity of the objective functions and constraints is a simple one. They are both quadratic in the control variables. This simplifies taking their derivatives.

To make the problem more tractable, it is reformulated as a mathematical programming problem where the member constraints are met with equality rather than inequalities. This reformulation facilitates a further reformulation where the constrainted problem is restated as an unconstrained problem. Once the problem is stated as an unconstrained problem, there are widely-available techniques which can be applied to its solution.

The assumption that the member constraints hold with equality is fairly innocuous. The final solution must be checked however to make sure tendons and struts have appropriate member forces. An inappropriate member force for one of the constrained members, a tendon in compression or a strut in tension, means that particular constraint is not effective for the solution in question and should be removed from the problem, or the parameters of the problem should be altered so the constraint is effective.

The easiest way of reformulating a mathematical programming problem with equality constraints as an unconstrained problem is to use penalty2 methods. In the penalty formulation, the constraints are recast as deviations from zero and the sum of the second powers of these deviations is incorporated into the the objective function with a large positive coefficient. This formulation is especially useful in the initial stages of solving a tensegrity mathematical programming problem since it easily handles large deviations from the constraint requirements. This allows the initial coordinate values to be very rough approximations to the constraint requirements and eases the process of formulating the initial values.

Reformulated in penalty terms, the general tensegrity programming problem becomes:

$minimize w‾1 ⁢ l12 +⋅⋅⋅+ w‾ no ⁢ lno2 + P1, …,P nh, V1, …,V nv μ‾⁢ l‾ no+1 2 - l no+1 2 2 +⋅⋅⋅+ μ‾⁢ l‾ nm2 - l nm2 2 + μ‾⁢ s‾1 - s1 ⋅⋅⋅ 2 +⋅⋅⋅+ μ‾⁢ s‾ ns- sns ⋅⋅⋅ 2 + μ‾⁢ d‾1- W‾1 ⋅Pd1 2 +⋅⋅⋅+ μ‾⁢ d‾ nd- W‾nd ⋅ Pdnd 2 + μ‾⁢ c‾1- c1 ⋅⋅⋅ 2 +⋅⋅⋅ + μ‾⁢ c‾ nc- cnc ⋅⋅⋅ 2$

where $μ‾$ is a very large positive constant.

The second way of reformulating the tensegrity mathematical programming problem as an unconstrained problem is referred to here as the exact formulation. It uses the constraints to divide the basic point and vector coordinates into a dependent set and an independent set. The constraints are then solved for the values of the dependent set in terms of the values of the independent set. The number of coordinates in the dependent set equals the number of constraint equations. Once this is done, the programming problem can then be treated as an unconstrained problem with the independent coordinate values as the control variables. Newton's method3 is used to solve constraint system for the values of the dependent coordinates. The exact formulation may not be suitable for the initial stages of solving a problem, since, if the initial coordinate values imply large deviations from the constraint requirements, Newton's method may not converge.

Reformulated in exact terms, the general tensegrity programming problem becomes:

$minimize w‾1 ⁢ l12 +⋅⋅⋅+ w‾ no ⁢ lno2 ; xd= hxi xi$

where $xi$ is a $3⁢ nh+nv - no~ +ns +nd +nc$ column vector and $xd$ is a $no~ +ns +nd +nc$ column vector which together contain all the $3⁢ nh+nv$ coordinates of $P1, …,P nh, V1, …,V nv$. The vector-mapping function $hxi$ is not determined explicitly. Its characteristics are determined implicitly from the constraint equations.

Many of the computations involved in solving and analyzing these two unconstrained mathematical programming problems require knowledge of the partial derivatives of the member lengths and non-member constraint equations with respect to the coordinate values. These partial derivatives can be represented as a matrix with $nm +ns +nd +nc$ rows, one for each member and each non-member constraint equation, and $3⁢ nh+nv$ columns, one for each of the coordinates of $P1, …,P nh, V1, …,V nv$. This matrix is referred to as $Ψ$. The element in the $ith$ row and $jth$ column of the matrix represents the partial derivative of the $ith$ equation with respect to the $jth$ coordinate. This element is referred to as $ψij$.

Since the member and constraint equations are linear or quadratic in the coordinate values, the partial derivatives are constant or linear in the coordinate values. This means it is easy to compute them using formulas. It is also possible to compute the partial derivatives using numerical techniques; however, this may yield less accurate results.

Frequently, submatrices of this matrix are referred to, so it is useful to partition the matrix. The matrix is partitioned over its rows into two submatrices called $Ψo$ and $Ψc$ which represent the partial derivatives of the lengths of the members in the objective function and the partials for the constraint equations respectively. This partitioning can be represented as:

 $Ψ= Ψo Ψc$

When the exact formulation is being used, the matrix is partitioned over its columns into two submatrices $Ψd$ and $Ψi$ which represent the coordinates classified as dependent and independent respectively. This partitioning can be represented as:

 $Ψ= Ψd Ψi$

For this representation to make sense, the columns of $Ψ$ must have been rearranged so all the columns corresponding to the dependent coordinates are on the left and all the columns corresponding to the independent coordinates are on the right. When the columns have been rearranged, $ψij$ continues to refer to the same partial it did before the columns were rearranged. For example, the partial $ψ7,5$ may refer to a partial in the second column of the matrix rather than the fifth column as it did before the rearrangement of the columns.

Both of these partitionings can be combined to get the following representation:

 $Ψ= Ψ o∩d Ψ o∩i Ψ c∩d Ψ c∩i$

For the exact formulation to work, a method for reliably dividing the coordinates into a dependent and an independent set must be found since not every partitioning results in a solvable system. For the system to be solvable, the square $no~+ nc+ ns+ nd$ by $no~+ nc+ ns+ nd$ submatrix $Ψ c∩d$ must be non-singular, and the further bounded away from singularity it is, the more robust it is in solving for new values of the dependent coordinates when the values of the independent coordinates are changed.

To get a good partitioning, the following method can be used. Start with the submatrix $Ψc$ which has $no~+ nc+ ns+ nd$ rows and $3⁢ nh+ nv$ columns. The $ijth$ element of this matrix, $ψ ijc$, represents the partial derivative of the $ith$ constraint with respect to the $jth$ coordinate value. Gaussian elimination is applied to the matrix with pivoting both over rows and columns.4 At the end of this process, the coordinates corresponding to the $no~+ nc+ ns+ nd$ left-most columns are selected as the dependent set. The remaining coordinates compose the independent set. If coordinate values change a great amount in the course of solving the mathematical programming problem, it may be advisable to recompute this partitioning to maintain a robust partitioning.

Once an unconstrained formulation of the tensegrity mathematical programming problem is selected, a method must be picked for solving the unconstrained problem. Newton's method can be applied here since the first-order condition of a solution requires the gradient of the unconstrained objective function to be a zero vector, or as close to it as the solution tolerances require. However, Newton's method is only really useful at the end of the solution iterations to increase the accuracy of the solution. If the coordinate values are not in the neighborhood of a solution, Newton's method diverges and isn't able to reach a solution.

Initially, it is best to use some sort of conjugate-direction method. Two effective methods in this category are Parallel Tangents (also called PARTAN)5) and Fletcher-Reeves.6 These and other conjugate-direction methods recommend themselves especially in conjunction with the penalty formulation since they are immune to the problems posed by the asymmetric eigenvalues of the objective function which results from that formulation.

Both of these methods require a method for doing a line search for finding which point in a given direction minimizes the objective function. One method is outlined below. It assumes the value of the objective function for the current coordinate values has already been computed.

1. An initial step size is selected and the point in the given direction found whose distance from the initial point matches this step size. The value of the objective function is computed at this new point.7
2. If the objective function value is larger at the new point, the step size is halved until a decrease is obtained, and halving continues until no more improvement (i.e. no more decrease in the objective function) is obtained. If the objective function value is smaller at the new point, the step size is doubled until no further decreases are obtained. In this second case, if the first doubling of the step size doesn't result in an additional decrease, the original step size is halved to see if that results in a decrease. If it does, halving continues until no further decrease is realized.
3. A quadratic technique is used to fine tune the step size. Three points are selected from the doubling/halving process above: the initial point, the best point and the point selected after the best point. A quadratic curve is fitted to the step sizes and objective function values corresponding to these three points. Using this curve, the step size corresponding to the minimum value for the objective function is computed. The actual value for the objective function for this step size is computed. This procedure is repeated, substituting the new point generated for one of the old points. Repetition is terminated when no further improvement to the actual value of the objective function is obtained. The formula for computing the new step size is:

$sn = s22 -s32 ⁢o1+ s32 -s12 ⁢o2+ s12 -s22 ⁢o3 2⁢ s2- s3⁢ o1+ s3- s1⁢ o2+ s1- s2⁢ o3$

where $sn$ is the new step size, $s1$, $s2$, $s3$ are the step sizes corresponding to the three points and $o1$, $o2$, $o3$ are the three objective function values.

The final fine-tuning step is important since both PARTAN and Fletcher-Reeves count on the point being an accurate minimizing point in the direction chosen. Once a solution to the unconstrained problem has been reached using conjugate-direction methods, Newton's method can be applied to the unconstrained problem to improve the accuracy of the result.

1 The non-convexity is due to the strut constraints. For a proof, see Appendix B.

2 Luenberger73, pp. 278-280.

3 Luenberger73, pp. 155-158. This is also referred to as the Newton-Raphson method. It is usually presented in a univariate context. Here, the multivariate version of the method is used.

4 This is referred to as "complete" or "total" pivoting. In contrast to "partial" pivoting, swapping is done over both rows and columns instead of just rows. Elimination is done in the usual manner over just rows. This only gets a footnote in most treatments of Gaussian elimination since for most applications "partial" pivoting (pivoting over rows only) is sufficient. For example, see Johnston82, p. 31.

5 Luenberger73, pp. 184-186.

6 Luenberger73, pp. 182-183.

7 If the exact formulation is being used, it is possible that this step generates constraint deviations large enough that Newton's method doesn't converge. If this happens, the step size should be halved.