The software package ttrr emerged from the scientific research for [Mohr2011], [MohrSteinMatziesKnapek2012] and [MohrSteinMatziesKnapek2013].
First, I started with MatLab http://www.mathworks.de/ in my PhD research, but the problems were too hard for this great software package. Furthermore, MatLab does not support the solving of mixed integer programs on its own. Therefore I was looking for something else: I found GLPK http://www.gnu.org/software/glpk/ and Python http://www.python.org/ — both are great software!
Because it was simple, I did the visualization with MatLab http://www.mathworks.de/ in my PhD-thesis [Mohr2011]. To write ttrr, I do not want to use a commercial back end for the visualization or moreover point you to such a software. But if you like, you can do it on your own.
Contents
Truss topology optimization has its root in [Michell1904].
The analytically stated and known (cf. [Przemieniecki1968]; [Marti2003]; [BendsoeSigmund2004]) linear problem of the topology optimization of a truss with respect to its volume (plastic design) is given by the objective function to be minimized

with the bar lengths  subject to the equilibrium condition
 subject to the equilibrium condition

with the reduced geometry matrix  , the inner bar forces
, the inner bar forces  and the reduced applied external loads
 and the reduced applied external loads  . Further given are the constraints
. Further given are the constraints

for the linear elasticity by — for all bars equal — stress limits  and
 and  (e. g. yield points for pressure and tension of the material all bars are made of), and the box constraint
 (e. g. yield points for pressure and tension of the material all bars are made of), and the box constraint

for the cross sections of the bars  with the given maximal bar cross section
 with the given maximal bar cross section  . [1]
. [1]
Here  is seen as a design variable; otherwise we have
 is seen as a design variable; otherwise we have  as function and therefore no linear program.
 as function and therefore no linear program.
If more than one load (e. g. the set  of loads) is to be considered, one ends up at the known multiple load case. But how is it performed? How can we put more than one load in the above linear program? It is impossible! But we can ask for a robust solution — this means we consider the worst case: A solution for all
 of loads) is to be considered, one ends up at the known multiple load case. But how is it performed? How can we put more than one load in the above linear program? It is impossible! But we can ask for a robust solution — this means we consider the worst case: A solution for all  is searched. Now we really end up at the well known multiple load case: [3]
 is searched. Now we really end up at the well known multiple load case: [3]

All this is done by ttrr.ttrr().
| [1] | The maximal cross section is no limitation — it’s a feature! It provides the possibility to limit the cross section; but if you do not want this set a huge upper limit — but an adequate limit helps the optimization algorithms. | 
| [3] | Sorry for the compactness, but you can look at the literature all over the world. :-) | 
For robust optimization see [Ben-TalElGhaouiNemirovski2009].
The implementation in ttrr.ttrr_robust() follows [MohrSteinMatziesKnapek2012]. This means if perturbed loads  are given, they are composed by some perturbations of the unperturbed force
 are given, they are composed by some perturbations of the unperturbed force  . Due to the linear programming we can restrict ourselves to the extreme points of
. Due to the linear programming we can restrict ourselves to the extreme points of  .
.
If we start the other way round with an additional assumption, it becomes clear: Let  be a given force with a perturbation of
 be a given force with a perturbation of  . Then we are interested in a solution for all
. Then we are interested in a solution for all  . Obviously the extreme points are
. Obviously the extreme points are  and
 and  . Therefore a solution for all loads in the set
. Therefore a solution for all loads in the set  is searched.
 is searched.
So robust optimization in topology optimization is the same as the multiple load case with appropriate load cases. For  a polyhedron a finite number of extreme points is given. And therefore ttrr.ttrr() can be recycled.
 a polyhedron a finite number of extreme points is given. And therefore ttrr.ttrr() can be recycled.
In addition ttrr.ttrr_robust() provides features to calculate the extreme points of simple sets of perturbed forces.
The basic concept of topology optimization with regard to redundancy is described in [Mohr2011] and in [MohrSteinMatziesKnapek2013].
Redundant Topology Optimization of Truss means we are looking for the best topology of a truss with a redundancy as to the falling out of some parts of the structure. The dream is a structure which is functional even if a significant damage occurs to an arbitrary set of bars.
You should think of RAID [4]. [PattersonGibsonKatz1987]
For example, a RAID 1 is a bunch of discs and every disc does the work. This means every other one can fail. Following [Mohr2011] this is called “1-1/n”-redundancy (c.f. [Shannon1948] [PattersonGibsonKatz1987]). Transferred to structures this means we are looking for  different structures in the same design space fulfilling the task to sustain the load(s).
 different structures in the same design space fulfilling the task to sustain the load(s).
Let  be the cross sections of the bars for the structure
 be the cross sections of the bars for the structure  . The sum
. The sum  describes the cross sections of the bars for the complete structure. The complete structure is composed of the
 describes the cross sections of the bars for the complete structure. The complete structure is composed of the  structures
 structures  . With the selecting variables
. With the selecting variables  we can now formulate the problem as a mixed integer linear program: [5]
 we can now formulate the problem as a mixed integer linear program: [5]

From  follows
 follows  and
 and  .
.
This is done by ttrr.ttrr_redundant() for redundancy =  .
.
A RAID 5 (c.f. [PattersonGibsonKatz1987]) is more complex. It can be described as a simple code. To transfer this concept to structures we only need to know the behavior. A RAID 5 is a bunch of discs. Every single disc may fail and the others do the job together. Following [Mohr2011] this is called “1/n”-redundancy (c.f. [Shannon1948] [PattersonGibsonKatz1987]). Back to structures this means we are looking for  different structures in the same design space. Every single structure can fall out and the other ones should sustain the load(s) together.
 different structures in the same design space. Every single structure can fall out and the other ones should sustain the load(s) together.
Let  be the cross sections of the bars for the structure
 be the cross sections of the bars for the structure  . As before
. As before  describes the cross sections of the bars for the complete structure. The complete structure
 describes the cross sections of the bars for the complete structure. The complete structure  is composed of the
 is composed of the  structures
 structures  . If a structure
. If a structure  fall out, the resulting structure is
 fall out, the resulting structure is  . As mentioned before, this damaged structure should sustain the load(s).
. As mentioned before, this damaged structure should sustain the load(s).
With the selecting variables  we can now formulate the problem as a mixed integer linear program: [5]
 we can now formulate the problem as a mixed integer linear program: [5]

Trivially  holds and therefore
 holds and therefore  .
From
.
From  follows
 follows  and
 and  .
The damaged structures are also well defined:
.
The damaged structures are also well defined:

Clearly  holds. So we get for the damaged structures
 holds. So we get for the damaged structures  and for the complete structure
 and for the complete structure  .
.
This is done by ttrr.ttrr_redundant() for redundancy =  .
.
| [4] | RAID is an acronym for Redundant Array of Independent Disks. http://en.wikipedia.org/wiki/RAID | 
| [5] | (1, 2) MIP: mixed integer problem; MILP: mixed integer linear program. Because MIP in general is too time consuming everybody is only thinking of MILP and often calls it MIP. | 
Robust redundant topology optimization is nothing more than redundant topology optimization with appropriate load cases. This concept of redundant robust topology optimization is described in [MohrSteinMatziesKnapek2013].
![digraph succession {
rankdir=LR;
"robust" [label="ttrr.ttrr_robust"];
"perturbaton" [label="if necessary:\ncreate perturbed forces"];
"ttrr" [label="ttrr.ttrr"];
"redundant" [label="ttrr.ttrr_redundant"];
"robust" -> "perturbaton" -> "ttrr";
"perturbaton" -> "redundant";
}](_images/graphviz-612eaff25d429712cd041183582f59ed5083d6b5.png) 
For a linear problem possibly more than one edge of the polyhedron exists as a solution. So the solution of a linear problem is not unique — but the optimal object value is.
Let us consider the small example:

A visualization is given in Fig. Visualization of the simple LP.
 
Visualization of the simple LP
 and the polyhedron
 and the polyhedron  bounded by the constraints.
 bounded by the constraints.Without a lengthy calculation we can see that the optimal value of the objective function  is
 is  . The edges
. The edges  and
 and  are feasible, optimal and have both the same value of the objective function — the same for all points between these edges.
 are feasible, optimal and have both the same value of the objective function — the same for all points between these edges.
So in general you cannot expect a unique solution for a linear program. The simplex algorithm will find an edge as a solution. An interior point algorithm will typically find a solution between edges which are optimal. The following two pictures from Example: 2_load_cases_3_dim show this behavior — both are optimal for the same problem.
simplex interior point 

For the redundant topology optimization we have in every case more than one solution. For example let  with
 with  be a solution, then
 be a solution, then  is one, too.
 is one, too.
For the example Example: 2_load_cases_3_dim for a “1/3”-redundancy this is shown in the following table:
To mostly overcome this behavior we can require an order of the volumes of the structures:

This is implemented in ttrr.ttrr_redundant() with the flag “sort”.
To look at scaling behavior of the above linear programs let us consider the following structure:

The material parameters for the topology optimization of truss given to ttrr.ttrr(), ttrr.ttrr_robust() or ttrr.ttrr_redundant() are:
: the maximal allowed cross section of a bar
: lower limit for the allowed stress, e.g. compressive strength
: upper limit for the allowed stress, e.g. tensile strength
- density : density
The density is only used to calculate the mass of the structure out of its volume.
 is necessary for ttrr.ttrr_redundant() and gives an additional feature to ttrr.ttrr() and ttrr.ttrr_robust(). If its not wanted a huge value would disable it. But in any case it gives with
 is necessary for ttrr.ttrr_redundant() and gives an additional feature to ttrr.ttrr() and ttrr.ttrr_robust(). If its not wanted a huge value would disable it. But in any case it gives with  bounding values. So we have a closed feasible region.
 bounding values. So we have a closed feasible region.
 and
 and  are really used material parameters. Typical topology optimization is a preliminary design. Therefore it must not be totally accurate to the praxis. Typically
 are really used material parameters. Typical topology optimization is a preliminary design. Therefore it must not be totally accurate to the praxis. Typically  is chosen. So we can assume
 is chosen. So we can assume  for some
 for some  .
.

Easily to see the following program results in an equivalent optimum. With  we get:
 we get:

This is only a scaling. The magnitude of the loads is only a scaling, too. With  for some
 for some  we get:
 we get:

And furthermore with  the following program is equivalent, too:
 the following program is equivalent, too:

Keep in mind it is not required to change the objective function. For  the minimum of the functions
 the minimum of the functions  and
 and  is reached at the same point.
 is reached at the same point.
The size of the design space is not found directly in the linear program. In the geometry matrix  occur only the angles of the bars. So the magnitude of the size of the design space in meter or millimeter will result in the same optimal structure, because
 occur only the angles of the bars. So the magnitude of the size of the design space in meter or millimeter will result in the same optimal structure, because  is only in the objective function and will be changed by a scalar factor.
 is only in the objective function and will be changed by a scalar factor.
A scaling of

do not change the (relative) condition of the problem. But it can change the absolute condition and therefore helps the computer by the calculation.
To do so the functions ttrr.ttrr(), ttrr.ttrr_robust() or ttrr.ttrr_redundant() have the parameters  scale_sigma and
 scale_sigma and  scale_forces. To get the picture let us see how they transform the above problem:
 scale_forces. To get the picture let us see how they transform the above problem:

Now the calculation will be done with  ,
,  ,
,  ,
,  ,
,  and
 and  :
:

Afterwards  and
 and  will be transformed back.
 will be transformed back.
For a maximum magnitude of  of an element from
 of an element from  the absolute condition of the equation will be a little bit better. For a maximum magnitude of
 the absolute condition of the equation will be a little bit better. For a maximum magnitude of  of an element from
 of an element from  and from
 and from  the condition of the inequation will be significant better. If
 the condition of the inequation will be significant better. If  the design variables
 the design variables  and
 and  resp. will not be changed.
 resp. will not be changed.
References:
| [Ben-TalElGhaouiNemirovski2009] | Aharon Ben-Tal ; Laurent El Ghaoui ; Arkadi Nemirovski: Robust Optimization. Princeton University Press, 2009. http://press.princeton.edu/titles/9099.html | 
| [BendsoeSigmund2004] | Bendsoe, Martin P. ; Sigmund, Ole: Topology Optimization. Berlin, Heidelberg : Springer, 2004. ISBN 3-540-42992-1 | 
| [Marti2003] | Kurt Marti: Stochastic optimization methods in optimal engineering design under stochastic uncertainty. In: ZAMM, 83 (12): 795–811, 2003. http://dx.doi.org/10.1002/zamm.200310072 | 
| [Michell1904] | Michell, Anthony George M.: The limits of economy of material in frame structures. In: Phil. Mag. 8 (1904), Nr. 47, S. 589-597. http://dx.doi.org/10.1080/14786440409463229. | 
| [Mohr2011] | (1, 2, 3, 4, 5) Mohr, Daniel P.: Redundante Topologieoptimierung. Neubiberg, Universitaet der Bundeswehr Muenchen, Fakultaet fuer Luft- und Raumfahrttechnik, Diss., Dezember 2011. http://nbn-resolving.de/urn/resolver.pl?urn=urn:nbn:de:bvb:706-2664 | 
| [MohrSteinMatziesKnapek2012] | (1, 2) Mohr, Daniel P. ; Stein, Ina ; Matzies, Thomas ; Knapek, Christina A.: Robust Topology Optimization of Truss with regard to Volume. In: arXiv - Mathematics, Optimization and Control (2012). http://arxiv.org/abs/1109.3782v2 | 
| [MohrSteinMatziesKnapek2013] | (1, 2, 3) Mohr, Daniel P. ; Stein, Ina ; Matzies, Thomas ; Knapek, Christina A.: Redundant robust topology optimization of truss. In: Optimization and Engineering (2013), 1-28. http://dx.doi.org/10.1007/s11081-013-9241-7 | 
| [PattersonGibsonKatz1987] | (1, 2, 3, 4) Patterson, David A. ; Gibson, Garth A. ; Katz, Randy H.: A Case for Redundant Arrays of Inexpensive Disks (RAID). Version: Dec 1987. 1987 (UCB/CSD-87-391). — Forschungsbericht. — EECS Department, University of California, Berkeley. http://www.eecs.berkeley.edu/Pubs/TechRpts/1987/5853.html | 
| [Przemieniecki1968] | Janusz S. Przemieniecki: Theory of matrix structural analysis. McGraw-Hill, Inc., New York, 1968. | 
| [Shannon1948] | (1, 2) Shannon, Claude E.: A Mathematical Theory of Communication. Version: 1948. 1948 (1). — Forschungsbericht. — 379-423, 623-656 S. — The Bell System Technical Journal. http://cm.bell-labs.com/cm/ms/what/shannonday/paper.html |