Optimal Design of a Compliant
Rear Mountain Bike Suspension
Semester Project Final Report
ME 558 Discrete Optimization
Submitted 7/13/2017
OPTICYCLE
JAMES T. ALLISON
MICHAEL S. CHERRY
ZACHARY A. KREINER
Abstract
The objective of this project was to determine a novel topology for a compliant rear
mountain bike suspension by employing discrete and continuous design optimization
methods. The mathematical model we have developed accounts for horizontal and
vertical loading on the wheel hub, the path the rear wheel hub travels while in motion, the
total horizontal and vertical displacement of the hub, and the volume of the suspension.
For simplicity, we began with a nine-node mesh representing the possible design space,
but then increased the mesh resolution, demonstrating the scalability of our parametric
model. The final model is a sixteen-node, undirected graph where the elements
connecting the nodes indicate the possible orientation of beams that compose the rear
suspension. We have designed and built a custom MATLAB code to analyze this space
and minimize a multi-objective function consisting of the path error with respect to a
circular path about the bottom bracket, the suspension volume, and the horizontal
displacement. Using this optimization program, a Pareto surface was then generated to
illustrate the tradeoffs between the multiple objectives. With this code, we have been
successful in determining an optimal topology that is lightweight, very stiff in the
horizontal direction, and closely follows the desired path.
Table of Contents
Problem Statement .............................................................................................................. 2
Design Model .......................................................................................................... 3
Mathematical Model ........................................................................................................... 5
Definition of Design Variables ............................................................................... 5
Definition of Constraints......................................................................................... 6
Definition of the Objective Functions..................................................................... 6
Optimization Method .......................................................................................................... 7
Optimization Model Description .......................................................................... 11
Optimization Results and Discussion of Results .............................................................. 13
Conclusions ....................................................................................................................... 18
References ......................................................................................................................... 19
Appendix A: Optimization Code Structure....................................................................... 20
Appendix B: The MATLAB Optimization Code ................................................................ 21
1
Problem Statement
In today’s mountain bike market, the rigid rear triangle seen in bicycles for generations
has been widely replaced by a rear suspension to provide a smoother ride while trailriding and increased control on rough terrain. This trend towards high-performance
cycles has substantially increased the cost of the mountain bikes due to the assembly
costs and part manufacture inherent with rigid-link mechanisms. Much work has been
done in developing advanced models for full suspension mountain bikes [1,2,3], most of
which focus on rigid-link mechanisms. Team OptiCycle proposed that a novel compliant
mechanism could be designed to replace these rigid-link rear suspensions in a simple and
cost-effective manner with a compliant suspension. The rear triangle of a mountain bike
(See Figure 1, below) has many product requirements that work against one another,
making it an excellent choice for an optimization problem that implements compliant
mechanisms. These requirements are as follows:






The compliant suspension should attach rigidly to a given seat tube geometry.
The suspension should be lightweight.
The suspension should be reliable, i.e.- exhibits a high fatigue life, high corrosion
resistance, and high strength.
The hub should travel a prescribed path while under both horizontal and vertical
forces, as well as torsion.
The dynamic response of the rear suspension should enhance mountain bike control
and comfort.
Finally, the ergonomics and aesthetics of the suspension should be considered.
Figure 1: A diagram indicating which section of the mountain bike will be modeled for
the creation of a novel compliant mechanism
Seat tube
Rear triangle – to be
replaced by compliant
suspension
Rear hub
Vertical
direction
Bottom Bracket
Horizontal direction
2
These requirements provide an ideal topology optimization problem due to the
conflicting nature many of them have with one another. Mountain bikes are used under
extremely rough conditions, making strength a key component in any design, yet the
carrying weight of the bike should be as low as possible, making heavy and overly strong
components infeasible. Also, the suspension has to be stiff enough to restrain the forces
induced during normal use, while at the same time it must be compliant enough to
provide the correct amount of deflection under a prescribed force. These inverse
relationships increase the difficulty of building a suspension, and necessitate the aid of
computer optimization to find an acceptable design.
While each of the considerations is important in the design of a compliant rear mountain
bike suspension, many of them were beyond the scope of the project. In this light several
simplifying assumptions were made. For this initial problem, dynamic effects, fatigue,
buckling, and stress have been ignored. These are acceptable assumptions to make,
because they are intimately related to the stresses inside the geometry, and stress is
typically ignored during the topology optimization stage for compliant mechanisms [4].
To further simplify the problem, we assumed the problem was two-dimensional, with a
uniform depth. This means that torsion and lateral rigidity (stiffness out-of-plane under
torsion about the seat tube) will also be ignored. In the beginning, aesthetics and
ergonomics were also ignored, but as possible topologies were proposed later, they would
again be considered based on the opinion of the team members. One final simplification
is to constrain the material to 4130 steel, removing a degree of freedom from the model.
With these considerations removed, the problem was formulated with three objective
functions and one constraint. First, the path accuracy would be measured and minimized
against a circular path using a sum squared error approach. Second, the volume would be
minimized, as well as the deflection in the horizontal direction under a substantial
horizontal load, as is the case for braking. The single constraint was that any considered
topology should deflect 5cm under a maximum force of 2400N, the force of an average
rider under 3gs where g is the acceleration of gravity (9.8 m/s2). This would ensure that
the suspension would have the correct deflection during trail-riding. More deflection was
not considered because it would send the system into the non-linear region, increasing the
computational time by as much as 2000 times.
Design Model
With this formulation, the design space was set up as a grid of nodes connected by
elements indicating the possible paths the suspension could travel from the rear hub to the
seat tube, and the initial nine-node, eighteen-element space used to replace the rear
triangle can be seen below in Figure 2. Each element in the space can be turned on or
off, changing the design. Once our design method worked on this simple mesh, we
planned to refine the mesh until the design model approximated a continuous design
space, allowing for complex designs such as curves and tapered beams. Discrete
optimization is ideal for such a formulation, because it allows for the simple addition or
removal of these elements. The problem would also include continuous optimization in
the form of the thickness of the elements.
3
Height of the
seat tube
Rear wheel
hub node
Angle of the seat
tube from vertical
Length of the system from the bottom
bracket to the rear wheel hub
Figure 2: The initial design space, a nine-node, eighteen-element system
One challenge presented by this design model was system connectivity. For a design to
be valid, the rear wheel hub must be physically attached to the seat tube at least at one
point. A disconnected, invalid design can be seen in Figure 3, below. Such disconnected
designs were dealt with in two different fashions which will be explained later.
Figure 3: A disconnected, invalid design
Height of the
seat tube
Angle of the seat
tube from vertical
Rear wheel hub is in
no way connected to
the seat tube.
Length of the system from the bottom
bracket to the rear wheel hub
4
Mathematical Model
The model, design objectives, constraints, and variables can now be presented formally in
negative null form:
Definition of Design Variables
The variable x is a binary vector. When the element based design model is used, each
element of x represents the existence of the corresponding element within a design. (0 →
doesn’t exist, 1 → does exist). This allows for direct design modification by adding or
removing elements. When the path based method is used, each element of x instead
describes the existence of a singly connected path. This allows for indirect design
modification by adding or removing paths. One advantage of the path based method is it
guarantees connectivity of the design, whereas the element method does not.
Beams with equal depth and thickness were used to describe all the elements in each
design. The continuous scalar variable t indicates this value. (All beams had the same
depth and thickness.) In future work, a vector t could be used instead to allow each of the
elements to have a different thickness.
The weighting parameter wi is necessary for the optimization model, and is not a true
design variable. It will be described in detail in the definition of the objective function.
5
Definition of Constraints
The only explicit constraint for our optimization model is an equality constraint that
requires the maximum vertical deflection attained by each design (δmax) when subjected
to a prescribed force is equal to the target deflection (δtarget). If the deflection is too low,
the design won’t have the correct stiffness, and if the deflection is too high, the design
will travel into the non-linear range, invalidating our computer model. The FEA code
designed by our team varies the thickness of all the beams until a value is found that
meets this equality constraint for a particular design topology. Because only one
thickness value will meet the constraint for a particular design, discrete choices are
imposed. In addition, because of this equality constraint, t may be viewed as a dependent
variable, rather than an independent design variable. The only true independent design
variable is x .
Other discrete constraints are imposed implicitly. x corresponds to the existence of
elements in the predefined design space. An element outside of the design space cannot
be selected. This implicit constraint imposes discrete design variable options.
Definition of the Objective Functions
We have set up this design problem with three objectives to be minimized; the path error,
the volume, and the horizontal deflection. These objectives ensure the optimal design
will have the necessary specifications for a rear frame and suspension with respect to the
scope of this project.
It was desired that the hub of the rear wheel should travel in a circular path about the
bottom bracket of the mountain bike. This circular path ensures no force feedback
through the chain when the suspension is active, and reduces suspension bobbing
resulting from pedaling forces. Each design was placed under five load steps, and the
position of each point was evaluated against a circular path. The sum squared error of
these evaluations was used as the first objective function to be minimized.
For optimal suspension performance, the mass of the design should be as small as
possible. Since mass is proportional to system volume, volume was used as the second
objective function to be minimized. The length of all the existing elements was found,
and multiplied by the square of the uniform thickness to calculate the system volume.
The horizontal deflection is the longitudinal movement of the rear wheel hub (parallel or
antiparallel to the direction of motion) that occurs when longitudinal forces are applied to
the rear wheel (braking or acceleration). The horizontal deflection was used as the third
objective function to be minimized. It should be small because as the hub moves
horizontally, the length of the wheelbase changes, and results in poor handling.
Since three objective functions are used, an approach must be used to convert the three
objective functions to a single value, since a vector cannot be minimized. Two popular
methods are to either create a composite objective function by summing the weighted
values of the individual objective functions, or by choosing an objective function, and
6
converting the remaining objective functions to constraints. We chose to use the former
method. wi is a weighting parameter used to vary the importance of each of the objective
function values. wi is continuous, and is determined using a normalization method to
ensure each set of wi values results in a unique optimal design. A collection of these
different optimal designs found using different weighting factors can be used to generate
a Pareto surface that will be described later.
Optimization Method
The nature of the problem undertaken requires the use of a heuristic algorithm. There is
no continuous counterpart to the topology optimization problem. In the approach used in
this project, the existence of each element in the node matrix is easily represented as a
single binary number. The string of all the binary numbers then completely describes the
topology of the structure, or design. This type of binary representation lends itself well to
using a genetic algorithm (GA) for optimization. The other alternative we considered
was simulated annealing (SA). In general it seems that SA requires a much larger
number of calls to the analysis function than required by a GA. The analysis function
consists primarily of assembling the stiffness matrix for the specified topology, and
applying various force loads, returning the resulting displacements. This function
required approximately 0.4 seconds to execute, and thus was a limiting factor in our
choice of optimization methods and parameters.
As mentioned previously, a unique challenge faced in this topology optimization was
maintaining connectivity between the rear hub where the wheel is mounted, and the seat
tube on the rigid frame. Two techniques were addressed to handle this problem, the path
and the element methods for determining element existence. The path method guarantees
connectivity by considering each possible connected path from the rear hub node to the
nodes of the seat tube as a design variable. The element method considered each possible
element connecting two nodes to be the design variables, and therefore does not ensure
connectivity.
In order to use a path method, each possible path from the rear hub to the seat tube
needed to be enumerated. This was accomplished by creating the adjacency matrix for a
given mesh, and running a modified one-to-some depth-first search algorithm to find all
possible paths and store them in a matrix. (See Figure 4)
7
Figure 4: The path method builds the suspension from combinations of paths
Path taken
Possible paths
Compound path can only be found by
combining paths from pathmake.m
For a 3x3 node mesh, there were 113 possible paths, and thus the optimization required
113 binary design variables, representing the existence of each path in the specified
design. Before running the analysis function, an additional step was required in which
the set of existing paths was decoded into the existing elements by taking the union of all
the elements in the existing paths for a single design. Figure 5, below shows one
optimized 3x3 design space.
Figure 5: The optimal 3x3 topology found by the element method
Vertical Location (in)
Notice the extremely
dense nature of the design
(only 4 elements left out)
*The red lines indicate the
locations of the elements
over several load steps.
Horizontal Location (in)
8
A problem faced with this path method was densification of the designs in the population.
Any more than four or five existing paths resulted in a truss structure with very few if any
elements missing from the mesh. This problem was furthered by mutation and crossover,
because changing just one design variable could drastically alter the topology. Such
drastic changes made convergence on a global optimum difficult, if not impossible.
Another problem with the path method was its lack of scalability. The resolution of the
mesh must be increased if a viable compliant rear suspension is to be found, but to
increase the mesh to 4x4, the binary existence variables increase to 20,596. This is far
too many to be optimized with a genetic algorithm, so we had to find a different method.
To solve these problems, an element method for determining element existence was
devised. This method solved the problem of densification because each design variable
only indicated one element in the space, rather than an entire path in the space. This way,
mutations and crossovers would change the topologies less drastically, enabling
convergence on a global optimum. The optimal 3x3 design found with the element
method can be seen in Figure 6, below.
Figure 6: The optimal 3x3 mesh found by the element method
Vertical Location (in)
The element method converges on
a less dense mesh and the optimal
topology has a 25% better
fitness value.
*The red lines indicate the
locations of the elements
over several load steps.
Horizontal Location (in)
The issue of scalability was also addressed by the element method. With each binary
existence variable indicating only one element, the number of variables for a 3x3 mesh
was reduced from 113 to 18, and for the 4x4 case it dropped to only 39 from 20,596. The
element method, however, does not ensure connectivity like the path method. Because of
9
this a check for connectivity had to be added. This is a simple check that will be
described later. Despite the necessity of this check, and due to its scalability and ability
to converge, we chose to continue the suspension project with the element method.
Once the decision had been made to use a genetic algorithm along with finite element
analysis, we had to create an optimization routine in which we could implement them.
Figure 7 illustrates the 4 methods we originally considered for our routine.
Figure 7: An illustration of the four solution methods considered
1)
MATLAB
GA implementation
2)
3)
4)
MATLAB
Control interface
GA implementation
Excel
Control interface
Ansys
FEA
Excel
Control interface
GA implementaion
Ansys
FEA
Ansys
FEA
MATLAB
Control interface
GA implementation
FEA
Choice 2) was our original approach. We were successful in creating an Excel
spreadsheet that generated input files for ANSYS, given geometric parameters and
element existence. ANSYS then performed FEA on the design, and passed back
performance values to Excel. We were pleased with the convenient interface, and the
sophisticated analysis done by ANSYS. However, the ANSYS runs were slow, and we
soon realized too slow to be used with a GA in a reasonable amount of time. Therefore,
we decided to sacrifice some convenience and some analytical precision for
computational speed, and use approach 4) instead.
To implement 4), we wrote a custom FEA code to analyze our designs. Nothing was
included in the code not required for analyzing designs within our design space
definition, which resulted in relatively fast evaluations and low computation time. The
10
code that we developed can be accessed through the link found in Appendix B, and the
functionality of the code used as our optimization routine is explained below.
Optimization Model Description
Appendix A outlines the structure of the optimization model developed for this project.
Six primary functions were coded in-house, along with several auxiliary functions. In
addition, functions were used from the MATLAB Genetic Algorithm Toolbox [5] and the
MATLAB Nonlinear Finite Element Toolbox [6]. The optimization model has three main
components: the custom finite element analysis, the genetic algorithm implementation,
and the assembly of the Pareto set. The following is an overview of these three
components.
The finite element analysis is implemented by the functions meshmake2.m, and FEA1.m.
meshmake2.m takes as an argument the binary vector x that fully defines the design
topology to be analyzed. A mesh is then generated that defines the design in a form that
can be used by FEA1.m to perform the required analyses (i.e. nodal coordinates and
beam element locations). This mesh is passed to FEA1.m. FEA1.m first performs a
continuous optimization on the variable t (the uniform beam thickness) to ensure the
equality constraint is met, i.e. the proper thickness is found to ensure the actual maximum
suspension deflection matches the desired deflection when under the given maximum
load condition. With this value for t, FEA1.m then calculates the deformed shape of the
suspension for five vertical load steps. The position of the node representing the rear
wheel hub is compared to a circular path, and the sum squared error (sse) is calculated
and used as an indication of path accuracy (objective function f 1  x  ). An sse value of
zero corresponds to a perfectly circular path. Using the value of t, and the calculated
lengths of each beam element used in the design, the system volume (proportional to
system mass) is found, and used as objective function f 2  x  . Finally, a large horizontal
force is applied to the hub node, and the corresponding displacement is used as f 3  x  . It


is desired to minimize this value. The vector f 1  x  f 2  x  f 3  x  is returned to
meshmake1.m, which then returns it to the genetic algorithm implementation.
The genetic algorithm is implemented by the functions SGA.m and OBFUN1.m. SGA.m
generates a random initial population of designs, and uses meshmake2.m and FEA1.m to
find the three objective function values of each design in the population. The prescribed
weight for each of the objective functions is then used to compute a single composite
objective function f  x  (or fitness) for each design in the population. The fitness values
are ranked, and genetic operations are used to develop a new population for the next
generation. The user can specify the probability of crossover and mutation, the population
size, the maximum number of generations, and the generation gap.
The function OBJFUN1.m is an interface between the genetic algorithm and the finite
element analysis. Given an entire population of designs, OBJFUN1.m sequentially passes
individual designs to meshmake2.m, which returns the corresponding objective function
values. OBJFUN1.m then assembles a matrix that contains the objective function values
11
for every design in a population for a particular generation. This matrix is passed up to
SGA.m.
After SGA.m has collected the objective function values and determined the
corresponding fitness values for each design in a population, it selects and stores the best
design from that population. After the maximum number of generations is reached, the
best design from all generations is found and returned. This generally is the best design
from the last generation if the genetic algorithm parameters were tuned properly.
As the code was developed, it was discovered that the genetic algorithm occasionally
generated a zero element design, which then caused the entire program to fail. Checks
were implemented into meshmake2.m for this condition. If a zero element design was
generated, a rather large fitness value was returned. This allowed the genetic algorithm to
operate normally, while preventing the code from failing. Other checks had to be
implemented as well, and after careful attention to robustness, a model was developed
that could handle any given design without failing. This was important so that the model
could run extensive models reliably without concern that it would fail sometime during
the middle of the run.
The above describes how the model finds the best design given a particular set of
weighting factors. Now it is left to explore what happens as these weighting factors are
varied. This will enable the quantification of tradeoffs between the objective functions,
which frequently are conflicting in design optimization problems. The function pareto.m
generates appropriate values of weighting factors, passes them to SGA.m, which then
returns the best design given those weighting factors. The best design represents a point
on the Pareto, or efficient surface. The user can specify how many points are obtained by
pareto.m. Once all points have been found, interpolation is performed between the points
to generate an approximation of a portion of the Pareto surface for the design
optimization problem. This surface is useful for both visualizing and quantifying the
tradeoffs present in the optimization problem. A design point may be manually selected
from the surface, using intuition and a feeling for what objective functions are most
important, or statistical methods may be used to select a point from the surface. The two
statistical methods used in this project were minimizing the maximum variation, and
minimizing the summed variation. In addition, a Pareto surface may be incorporated into
a profit model using market and other criteria to select a best design. In this case a single
optimum may be available.
Both the path and the element methods for dealing with connectivity were implemented
in the optimization model. Both versions are available in the zip file obtained by going to
the link in Appendix B. Changes had to be made throughout the model to convert from
the path method to the element method. The only function not altered was pareto.m.
Using the path method, a matrix containing all of the singly connected paths was
generated by a function pathmake.m, which was called by SGA.m. SGA.m used binary
vectors to describe each design that had as many variables as there were paths in the path
matrix. For example, if paths 1, 18, 49, and 111 contained a 1 in their respective bits in
the binary design vector, the corresponding design was a union of paths 1, 18, 49, and
12
111. meshmake2.m was written such that these paths were converted to element
existence, and then knowing what elements existed, the mesh for FEA1.m could be
generated. Because the design consisted of a union of connected paths, it was guaranteed
to be connected.
The optimization model was converted to an element based method when it discovered
that finer meshes using the path method quickly became unwieldy, requiring very large
numbers of design variables, even for a simple 4 node by 4 node mesh. Using the element
method, the binary design vector in SGA.m corresponded directly to the existence of
elements in the design. Because of random element selection, connectivity was in no way
guaranteed. A simple solution was to recognize that a disconnected design produced a
singular stiffness matrix for the finite element analysis. A check for singularity of the
stiffness matrix was implemented in FEA1.m. If the stiffness matrix was singular, the
function was terminated, and a large value was returned for each of the objective
functions (just as in the zero element design check described above). The scaling up to a
4 by 4 node mesh was successful, and in the future all that will be required to go to a
more refined mesh is to provide the appropriate adjacency matrix in meshmake2.m, and
change the number of variables in SGA.m to match the number of elements. The scaling
up of our model from a 3x3 to a 4x4 mesh demonstrates the scalability and parametric
nature of our code.
Optimization Results and Discussion of Results
Numerous optimization trials were conducted to determine the best possible topology for
the rear suspension. The most comprehensive set of results for the 4x4 case was a 97
point Pareto surface that took 5 days to run. A Pareto surface represents the trade-off
between the multiple objective functions. Each point on the surface represents an optimal
design, but with different weighting constants. The “global optimum” can be chosen in
many different ways. For this project, the designs with the minimum maximum variance
and the minimum summed variance were chosen and compared. The specified two
points are shown in Figure 8 below.
13
Figure 8: The Pareto Surface of 97 different optimization trials, each with a unique set of
weighting constants for the objective functions.
Point chosen by
min(max(variance))
Point chosen by
min(sum(variance))
Horizontal
Deflection
(in)
2
Path Error (in )
Volume (in3)
Figure 8 shows the surface of optimal designs from which the two best designs were
chosen using differing statistical methods.
The variance is the variation from the lowest objective function value for each of the
three objective functions and is merely a way of normalizing the multiple objectives. The
maximum variance for a design is the largest of its three normalized objective function
values, and the summed variance is then self-explanatory. The optimal design for the
min(max(variance)) was the design that had the lowest maximum variance. Likewise, the
optimal design for the min(sum(variance)) was the one with the lowest summed variance.
The two designs described herein are presented below in Figure 9.
14
Figure 9: The two topologies statistically determined from the Pareto Surface.
min(max(variance)) method
min(sum(variance)) method*
*This method provides a more aesthetically
pleasing and ergonomically sound topology.
Figure 9 shows the two designs that were found by using statistical methods for choosing
the best design from the 97 optimal points.
While Figures Y and Z illustrate there are different statistical methods for choosing a
point on the Pareto surface, human intuition was used to make the final decision, as is the
case in almost all design projects. The factors considered in this decision were aesthetics
and ergonomics, which had previously been neglected. Using these criteria Team
OptiCycle chose the design obtained from the min(sum(variance)) method as the
preferred “global optimum.” The term “global optimum” has been used with quotes
because a heuristic algorithm does not guarantee that there are no neighboring designs
with a better fitness, unlike a continuous optimization algorithm. The GA does, however,
increase the probability of exploring the entire design space, and therefore instills greater
confidence that the optimum is global and has not converged prematurely on a local
optimum.
Another important feature to notice from the Pareto surface is the tradeoff between the
different objective functions. There is a distinct curve between the axes representing the
path error and horizontal deflection, but relatively no slope when either one is compared
to the volume axis (see Figure 10 below). In other words, the optimization method was
insensitive to the weight on the volume objective. We believe this can be explained by
the way the equality constraint was formulated. During the analysis function call for
each design in the population, the thickness was optimized as a continuous variable until
the maximum vertical deflection was the pre-specified 5cm. For a given topology, the
length of all beams is fixed because the nodes were not allowed to move, and the
thickness is mandated by the desired deflection. The volume is simply calculated as the
15
sum of each beams length multiplied by the thickness squared (square cross-section
assumed). Therefore, although the volume was an objective function, it was overconstrained and the Pareto surface plots below were the result.
Volume
Long. Deflection
Figure 10. Pareto surface displaying lack of tradeoff between Volume and Longitudinal
Deflection and Volume and Path Error.
Volume
Path Error
With the optimal design chosen, ANSYS was used to verify the performance and
evaluate the stresses. The results of this can be seen below in Figures 11 and 12.
Figure 11: Axial stress results from ANSYS
Largest axial stress is
134 GPa in compression
16
Figure 12: Bending stress results from ANSYS
Largest bending
stress is 1.6 GPa
in tension
Figures 11 and 12 show that in both cases the maximum stress is far higher than yield for
any material.
The maximum deflection and path of travel were within 2.5% of the behavior predicted
by the MATLAB analysis function. This provided well-needed validation of the model
used for optimization. However, while validating the accuracy of the model, it was
discovered that the stresses required to obtain the predicted performance are well beyond
any material’s ultimate strength. The high axial stresses are related to the type of model
used for the FEA analysis, which are further related to the computation time required for
optimization. A linear analysis was used to model the deflection under a vertical force.
The desired path of travel was circular, but a cantilever beam under a vertical force, for
example, does not result in any horizontal deflection. Thus, the only way to obtain the
desired deflection was to induce axial strain. If a non-linear analysis had been used,
bending would have contributed to the horizontal deflection required in a circular path.
However, non-linear analysis is much more computationally expensive (2000X for the
nlfet code used). For a GA with multiple thousand analysis function evaluations
required, this was not deemed feasible. The stress problem can be further ameliorated
through the implementation of a stress constraint for yield and buckling. This would also
increase the computation time, but would provide a more realistic model.
17
Conclusions
A topology optimization routine was performed for a fully compliant rear mountain bike
suspension design. A suspension design was successfully found based on the objectives
considered. Namely, the error from the desired deflection path, the design volume, and
the horizontal deflection were minimized subject to an equality constraint on the
maximum vertical deflection. While a design was found that fulfills all of the
requirements evaluated, further advances to the complexity of the model are required to
obtain a more realistic result. This includes allowing each segment of the design
topology to vary continuously in thickness, introducing stress constraints for yield,
fatigue and buckling, and switching from linear to non-linear analysis. Other possible
suggestions for improvement would be to include damping for dynamic performance,
evaluating different materials, allowing the node locations to vary continuously, and
analyzing 3-dimensional effects such as torsion. These changes would drastically
increase the computation time but would result in a functional prototype design.
18
References
[1]
Good, C. and J. McPhee, 2000. “Dynamics of mountain bicycles with rear
suspensions: design optimization.” Sports Engineering, Vol 3, pp 49-55.
[2]
Titlestad, J.K. et al., 2003. “Numerical and Experimental Simulation of Mountain
Bike Suspension Systems Subject to Regular Impact Excitation.” Materials
Science Forum, Vols. 440-441, pp. 111-118.
[3]
Sasaki, K. et al. “Path Analysis. A Bicycle Rear Suspension Analysis Method.”
http://www.mtbcomprador.com/pa/english/ accessed on 10/1/03.
[4]
Hetrick, J.A., 1999. “An Energy Efficiency Approach for Unified Topological
and Dimensional Synthesis of Compliant Mechanisms.” Ph.D. Thesis, University
of Michigan, Ann Arbor.
[5]
The Matlab Genetic Algorithm Toolbox, http://www.shef.ac.uk/%7Egaipp/gatoolbox/intro_paper_1.pdf (from IEE Colloquium on Applied Control Techniques
Using MATLAB, Digest No. 1995/014, 26 Jan, 1995)
[6]
The Matlab Non-Linear Finite Element Toolbox (NLFET),
http://cvs.sourceforge.net/viewcvs.py/nlfet/nlfet/ written by Roberts, M., accessed
on 10/1/03.
19
Appendix A: Optimization Code Structure


pareto.m

Generates weight values
Calls SGA to assemble set of optimal
designs.
Selects best design according to statistical
criteria
 w1 
w 
 2
 w3 
x*
     
f1 x* f 2 x* f 3 x* x*

Implements genetic algorithm to find best
design topology for a given set of weights.
SGA.m
  
 x1 
 
 
x 
 n
 f x f12 x f x 
13
 11





 f n1 x f n 2 x f n 3 x 


  

OBJFUN1.m
Assembles matrix containing objective
function values for each individual in a
population.
  
x
f1 x , f 2 x , f 3 x

Generates a mesh for finite element analysis
given a design.
meshmake2.m
t
FEA mesh

FEA1.m

  
f1 x , f 2 x , f 3 x
Determines beam thickness required to meet
maximum displacement equality constraint.
Uses FEA to calculate all three objective
function values.
20
Appendix B: The MATLAB Optimization Code
The full optimization model may be obtained by going to the following link and clicking
on OptiCycle_code.zip.
http://www-personal.umich.edu/~jtalliso/Research/
The forests of America thank you.
21