Hyperboloid Bridge tutorial in Generative Components

This is an edited and revised aversion of a tutorial written as coursework

whilst at Liverpool University School of Architecture, on Andre Brown,
Michael Knight and Martin Winchester’s Advanced CAAD third year module.

The text and images refer to an early version of Generative Components v8,
therefore the programme set ups maybe slightly different and the images
may not be exact to what this version of the tutorial gives you. Having used
v8i, which is the latest version – the information here can still be applied. The
downloadable .gct file has been composed, tried and tested in v8 XM 8.5.5.

If you are new to GC the first thing to understand is the interface.

Figure 1

View 1, the symbolic view, shows the components relationships. The main
view, view 2, shows the geometric result and the features you have placed to
form it. It shows your physical model and you can drag and move around the
features within in it, altering the model. You can pan around the model and
visualise the design. The Transaction File (TF) is the generative components
panel in which you define and alter variables within the model. The system of
boxes in the middle is the main plane system. The plane with the yellow box
is the active plane. These windows will not be quite arranged as seen here
but like any window, they can be moved around and altered to preference
but it is suggested you can see all the windows at the same time. (Figure 1)

Save the TF (TF stands for transaction file), in the form of a .gct file, this can
be done by clicking File, Save on the tool bar of the TF. This saves the
instruction that is held within the TF, not the geometry. When you re-open the
file, the screen will appear blank, but do not worry all the information is held
within the TF. When it is opened a list with black dots appears under the title
‘transaction’, clicking one of these will turn it green and you can choose the
stage of the instruction to jump to. Each transaction can be expanded to see
what is occurring and also suppressed. These steps can be played through
by using the standard forward and backward buttons. This is a key feature
within parametric design, where the model does not need to be re-drawn to
see the different effects of altering a variable. To skip to this at any point
within design, click on the transaction file tab in the bottom left of the TF.
(Figure 2)

Figure 2 : Highlighting file tab, stages saved within transaction file and the
transactions tab

If you save after every step or major part of the build up, a new graph user
change will exist and if you name it you can quickly refer to, and alter a
specific transaction, suppress a transaction, add, delete or move a
transaction also.
Key buttons...

The following can be found on the toolbar of View 2

fit view

change display mode – switch between wireframe, shaded surface etc

rotate view, top view, side view, iso view, left view

These all relate to MicroStation as a drawing programme, which Generative

Components is run through.

The scroll wheel of a three wheel mouse can be used to pan and zoom by
holding it down and moving the mouse or by spinning the wheel to go
inwards and outwards.

The following is taken from the toolbar of the TF and further information can
be found in the help files.
TASK

It is advised that the tutorials under the Generative Components help tab are
completed first and this is used as an extension. This is because from
starting at the very beginning, there will be more understanding of certain
functions and points that are not explained in length etc. Although this
tutorial is still achievable with little to no experience, simple things such as
placing points and how to define and add new features have not been
covered, but these are both things covered very early on in the GC help files.

We shall be making a simplified version of the ARUP/Hodden bridge in

Manchester. The form is geometrically known as a hyperboloid. It is
constructed from glass and steel.

The following two web pages can be visited for more information on the
bridge and hyperboloid's.

http://www.arup.com/facadeengineering/project.cfm?pageid=1810

http://en.wikipedia.org/wiki/Hyperboloid).
Add a line via two points. (Figure 1)

Figure 1

Add a second line where the coordinates for the y translation correspond,
this will ensure it is an offset of the original. (Figure 2)

For example:

Point one = (5,-2,0), Point two = (5,2,0), Point three = (-15,2,0), Point four = (-
15,-2,0)
 Figure 2

Apply coordinate systems01 and 02 on the lines, with T of 0.5 and basecs.z
direction, using ByParameterAlongCurve as a definition.

Figure 3

Place tangent lines from coordinate system. Line,

ByStartPointDirectionLength, Coordinatesystem01 as start point, direction is
coordinatesystem01.Ydirection and length is arbitrary, therefore 2. Do the
same using coordinate system 02. (Figure 3)

Figure 4

Apply a tangent line which is in the form of a bsplinecurve. BSplineCurve,

ByTangents, {line03,line04}. (Figure 4)
 Figure 5

Apply points along the curve, which we will user as centre points for the
hoops. Point, ByDistanceAlongCurve, select curve and then apply series of
points eg. If the line is 20 long then Series{0,4,8,12,16,20}. Note : In the gct
file I originally placed points every 2, not 4. This is edited later on in the
process to use 0,4,8,12,16,20. (Figure 5)
 Figure 6

Point05 is now an array of points therefore we can apply a circle to one of

them and get a circle on each point. To do this we do circle,
ByCentreRadius, specifying point05, the radius which we know to be
sensible, so 3.0 and then the support as coordinateSystem01.XZPlane to
define what direction the circle is to follow.

Should one of your circles not be sat on the line as shown in Figure 7, edit
point05, take out the end figure and apply BSplineCurve.length as the end
part of the series. This means that we are applying something to the end of
the curve and not a figure on the curve which can confuse the scripting. We
would then have {0,4,8,12,16,bsplineCurve01.Length}
 Figure 7

Figure 8

We now need to apply points along the circles to start the lacing from (Figure
8). Point, ByParameterAlongCurve. By placing a point on one of the circles –
which exist as an array, we shall see the point on every circle. If we make the
point a series, that series will exist on all the circles. So if we choose circle01
as the curve and then define T as ‘Series(0.0,1.0,0.1)’ we will get points at
every 0.1 increment from start to finish. We then need to hit the ‘Toggle
Replication Style’ button on the TF to apply this, this maximises the possible
replication from our inputs.

Next we apply the first set of lacing, which will join on circle[1] to circle[2]
from point06[1][3] to point06[2][4] and so on, where the circle index will
increase by one every time, as will the point indices, apart from when joining
then end hoops. This can be seen in Figure 9.

Figure 9

This is done by Line, ByLacingFromPointGrid and define point06 without

brackets and index references. The position index should be 0 and the lacing
method should be LacingOption.PositionIndex.

We then need the lacing to work in the opposite ‘direction’, so that it would
go from point06[1][3] to point06[2][2] and then point06[3][1] and so on. To do
this we do the same but input the optional position index as 10. This figure
tells the script to do the opposite. (Figure 10)
 Figure 10

We now apply what is called a law curve, which will allow us to control the
form overall/make it interactive, and will be controlled by points in a graph,
linked to the radii of the inner hoops, via ‘dependent variables’.

First, we require a new control space in which to place a graph, which can
then be linked. So to do this we specify a new coordinate system. Coordinate
System, AtModelOrigin and type “control2”, including the speech marks. A
new window with the new coordinate system will appear. Within this we can
now apply the Law Curve Frame.
 Figure 11

This is achieved by LawCurveFrame, FromPlane. If we hold control and

hover, we can input control2_baseCS.XYPlane as the plane. It is very
important that we are working in one plane only. The dimension can be
specified, say 20 and 10, this will just define how big the graph is. We can
then put what each axis will range. So if we put {0,5} for the X axis, we are
specifying that we will be able to move the points we put within the graph
between these extents. Then if we put {3,8} for the Y axis we are stating the
Radius cannot get any bigger the 8 but no smaller than 3. This is the idea in
theory but may not work in practice here. What is important is that we are
learning the techniques. I have used 5,20 which gives me a huge amount of
freedom. I know 5 to be too large a figure, but to highlight how we change
elements using the Edit Feature button, change it to 0,20 – which realistically
is to small a figure.

We now need to place our points within the graph. What we shall do is place
four points. The outer two will sit on the outer reaches of the X axis and the
inner two we shall move around to change the form. We could place more,
but realistically in this scenario, moving two points and keeping the outer
hoops fixed will have the greatest effect. To place these points, use Points,
OnPlane. This is again so that we stick to one plane. Therefore we hold CTRL
and hover over the coordinate system so that we get
‘control2_baseCS.XYPlane’ in the Plane input. It is pivotal that all the four
points have this. Change the X translation of the first point to 0. Then repeat
with another two points within the graph space, leaving the X translation
alone and then for a fourth point, changing the X translation to 20. Figure 11
shows the points within the graph.
We then need to apply the actual curve which is done by LawCurve,
ByControlPoints. First we specify the LawCurveFrame which can be done by
hold CTRL and hovering over the frame, giving ‘lawCurveFrame01’.

Next input the points as Controlpoints, as a list, therefore

{point07,point08,point09,point10}, and make sure they are in the order in
which they exist left to right. If we make the CurveControl input box active we
are immediately faced with an options list. Select ByPoles, although in this
case it would have little affect which way the curve was controlled.

Put the order as 3. This is for the same reason as before in that 2 would be a
polyline and 4 is the maximal control points.

For the IndependentVariables, input ‘Series(0,5,1)’, which is defining a series

of variables. We will fix the curve to the circle at a later point.

Figure 12

Something like Figure 12 will now exist.

We now need to give the bridge some substance and so we will apply cones
to make the form look like it is made from steel tubing. To do this we apply a
cone via, Cone, ByLine. Select one of the sets of lacing, eg line06. Specify a
start and end radius, 0.1 will look sensible. Then repeat this to the other set
of lacing. Figure 13, show both sets on cones applied.
 Figure 13

We also need to do this to the hoops. We do this once and it will apply it to
all of them. We will have to do this as a BSplineSurface. Therefore,
BSplineSurface, SweepCircleAlongCurve. This will give us the same effect as
a cone did in the straight lines. Select circle01 as the curve, making sure the
indices are removed. For diameter put 0.2 and we put 0.1 as a radius for the
cones. (Figure 14)

Figure 14
For clarity, we can then hide the circles and the lines using the toggle as
before.

Figure 15

We can then apply a walkway via a set of points, lines and walkway. This is
simply done and is not covered but the .gct file can be used to see what
inputs and features have been used to create it. (Figure 15)

Next we shall fix the law curve to the circle radii. If you find circle01 in the
symbolic view (it will be white if hidden), the use the edit feature tool and
click on it. You can then edit the inputs the same as usual. We need to
change the Radius Input to ‘LawCurve01.DependentVariable’. To do this hold
control and hover over the law curve, then put in a full stop to bring up the
menu and then choose dependent variable. The radii of the circles are now
dependent on the position of the points in the graph.

We also need to ensure that the outermost points on the graph do not move
so edit them both and remove the ‘<free>’ inputs. The handles will then be
removed as seen in figure 16.
 Figure 16

You can also see that I’ve moved the points and the form has changed.

Figure 17

We can use the toggles to hide what is not necessary visually and by moving
the points we can get something near to the bridge in Manchester, shown in
Figure 17.

By moving the points we can get some of the following results…

This can be refined further by bringing in the actual angle of the walkway in
plan and section. The hyperboloid will still be similar but affected by these
angles.

To extend this tutorial further we could suppress some of the transactions

and apply a generative component to a point grid, in a very similar manner to
that of the tutorial under the GC help tab. This has been included in the gct
file and I have extracted the information from the GC tutorial to make it
understandable. It should be easy to apply this to the model if you suppress
the transactions regarding the lacing lines. This is a good task to undertake
as it explicitly shows the whole point of generative components – by taking
one simple feature, applying it to a system and if necessary getting a
completely different result and form for each iteration of it, even though you
have only drawn one. The .dll file is the generative component which can be
loaded via Tools_Manage Loaded Assemblies_Select Pre-complied
Assembly File (*.dll) should it be needed.

Some of these instructions may appear brief in what we do in places. This is

because they are not necessary to know in the early stage, but if this is
carried out with GC’s tutorials, the key techniques should now be picked up.

Information for applying a simple generative component (taken from the

Bentley GC help files which I then re-wrote for coursework on the Advanced
CAAD course at the University of Liverpool Architecture School) :

“Using these points we need to form the actual polygon grid. This is done by
Polygon, ByPointGrid. Remove the indexes and brackets leaving just
point05. The program then knows just to use all the point05’s to from a grid.
(This would be done with point06 in the hyperboloid task)

We will now make a crossbar panel which gives us a more elegant aesthetic
and can also be manipulated by the original four points. This will be created
away from the model and then applied.

Place four points as shown in Figure 12.

Figure 12 – Placing crossbar points

Make a polygon from these points via Polygon, ByVertices. The vertices will
be each of the four points. The polygon will be formed and hide the points as
in Figure 13.

Figure 13 – Polygon formed

Next, we create the diagonals, Line, Bypoints, where start point is

‘polygon02.vertices[0]’ and end point is ‘polygon02.vertices[2]’ and then via
create copy use [1] and [3] for the other. (Figure 14)

Figure 14 – Diagonals applied

A ‘cone’ is then applied to each diagonal, which effectively acts a tube in this
scenario. We do this by Cone, ByLine. The radius needs to be proportional to
the diagonal length and not a fixed figure so that the model works and can
be manipulated. Line should ‘line04’ and Startradius should be
‘line04.Length/25.0’. Repeat this for line05 using line05 where necessary.
25.0 is editable and arbitrary. (In the hyperboloid example, simply 0.1 as a
radius will suffice). The applied cones can be seen in Figure 15.
 Figure 15 – Cones applied to diagonals

This will now be turned in a user defined feature. To create one of these
select the fifth button along on the bottom bar of the TF. Select ‘from model’
under input properties. Choose polygon02 in the model space and it will go
green in the symbolic view, click OK. Check ‘Replicatable’ and check
‘construction’ for the two diagonals. Finally, name the feature, eg crossbar01.
(Figure 16)

Figure 16 – Creating User Defined Feature

Now all we need to do is place the feature. We do this the way we would
usually do for a line, bsplinecurve and so on, but choose the named file, eg
crossbar01 and define ByDefault. Choose polygon01 as the input and
remove the indexes. This means there will be a crossbar01 for every
polygon01. (Figure 17)”
 Figure 17 – crossbar01 applied.
If this is applied to the hyperboloid task and all the unnecessary lines, points
and surfaces are hidden, then the results should look exactly the same and
with the lacing, BUT one generative component has been applied and altered
numerous times across the form and more information could be taken from
this in terms of sizing etc. through excel and in theory for manufacture.

Excel inputs/outputs and fabrication planning are further tools which make
GC very worthwhile. These, along with all other features etc can be explored
at any time via the ‘Example’ button on the TF. This will not affect your
modelling or file, as it just opens up as a second symbolic and modelling
view which can be closed, and it will show how to use the definition and what
it requires.

Questions please…