Parametric modelling 1

Helix bridge

Lets create a relatively involved parametric design and experience the incremental development and experimentation involved. We will develop a parametric model, namely a rotating-polygon-along-a-spine scheme. As a reference we will use the Helix Bridge at MBS [>] by Cox Architects and ARUP Engineers. Of course we cannot develop this scheme too far, but we can capture its essential geometric logic.

Credits: Cox Architects

Spine Geometry

We begin with defining a curve which will become the “spine” of the design. This will allows later to control the overall design shape through a “global” type of handle. It is a good idea to start with a simple curve, e.g. a line or an arc, and use dimensions that are reasonable in scale. Here we use a 100 meter long line expressing the span of the bridge.

The “curve frame” component evaluates a Frenet coordinate system at a parameter along a curve. The coordinate system is returned as a plane entity which we analyse into its constituent entities using the “deconstruct plane” component.

20KB

3B_Bridge-01.gh

Rotating about the Spine

The next step is to develop a sequence of points rotating about the spine. We use the technique of evaluating points of a circle, using trigonometric functions because they express rotation in the XY-plane (or about the Z-axis). We use the x and y coordinates of those points as coefficients for scaling each plane’s normal and bi-normal vectors. Using basic vector algebra we constructed a sequence of points spiralling about the spine curve.

There is no new components in this section. Everything is developed based on simple arithmetic nodes. However, basic arithmetic nodes tend to clutter the graph and hide the logic. As an alternative, the video also demonstrates how using the “expression” component can help compacting the same logic.

Another way to think about this geometric construction, is in the sense of coordinate system transformation: we constructed points of a circle in the world coordinate system i.e. $o=[0, 0, 0]$, $x=[1, 0, 0]$, $y=[0, 1, 0]$ and $z=[0, 0, 1]$, and we rigidly translated and oriented them in the coordinate systems along the spine.

Consider a point $p=[1, 2, 3]$ with respect to the world coordinate system.

Its coordinates can be also expressed as $p = o + 1 * x + 2 * y + 3 * z$

or therefore $p = [0, 0, 0] + 1.0 * [1, 0, 0] +2.0 * [0, 1, 0] +3.0 * [0, 0, 1]$

or further computing $p = [0, 0, 0] + [1, 0, 0] + [0, 2, 0] + [0, 0, 3]$

or finally $p = [1, 2, 3]$.

The key observation here is that the values 1, 2, 3 represent translations along the basis vectors starting from the origin. If we change the coordinate system such that “q” is the point on the curve, “t” is the tangent vector, “n” is the normal vector and “b” is the bi-normal vectors, then we can express the same point with respect to the curve’s frame using $p’ = q + 1 * t + 2 * n + 3 * b$.

Putting this all together, in the graph above we mapped the points using the following expression:

$p’ = q + r * cos( c * s + p ) * n + r * sin( c * s + p ) * b$

where $r$ is the radius of the circle, $c$ “c” is the cycles around the circle, $p$ is the phase, or starting angle, around the circle and $s$ is the parameter along the circle.

24KB

3B_Bridge-02.gh

Rotating Frame Points

Next we duplicate the above logic region to produce four spiralling sequences along the spine. To avoid introducing too many new concepts at once, we will just copy and paste the logic block created earlier. Finally, to associate one spiral to the next we link them using 90 degrees offsets among their phases. Now you can see the reason for using the phase parameter. It not only allows us to link all spirals together but also define the starting angle of all points.

Again there is nothing new in terms of components. Here we use visual grouping of related nodes for capturing the logical regions of the graph. Select multiple nodes and press “control+g” to group them. Right click on a group to give it a name.

We also observe how fast the graph started getting a bit out of hand in terms of nodes and wires. Generally, copy-pasting logic, may this be graph nodes or code. is considered cringe-worthy exactly for this self-induced complexity increase. We will see in future sessions how to modularize and reuse logic blocks.

55KB

3B_Bridge-03.gh

Centreline Geometry

The next section is even simpler. Here we will construct what is known as centreline geometry: the skeleton of a design. This approach is heavily used in architecture and engineering because it expresses the minimum amount of information capturing the essence of a design, without extraneous details that is.

Spirals are constructed by simply using the “polyline” component. Frame edges are constructed by coupling points among spirals using the “line” component. The first operation is also known as “chaining” points into string(er)s, while the later as is often expressed as “lacing” points across parallel sequences.

     0  1  2  3  
P = [a, b, c, d]    ┐
     🡓  🡓  🡓  🡓     > → lacing → [a, w], [b, x], [c, y], [d, z]
Q = [w, x, y, z]    ┘

56KB

3B_Bridge-04.gh

Diagonal Bracing

Structures, such as this twisting truss, require a sense of triangulation for the sake of rigidity ie. to resist deforming. A triangle is a simplest planar object, where all length and angles are fully constraints. Rectangles on the other hand tend to easily distort into parallelograms when loads are applied diagonally. So here we will add what is known as diagonal “braces”. The goal of this is not to delve into the mechanical behaviour of materials and structures but to learn how to lace diagonally across lists.

Here we use the “split list” component. It requires a sequence of data elements (of any type) and an index after which it will split the list into two parts. Selecting sub-lists, slices or spans (these are all synonyms) is a highly common operation!

Now let’s consider two sequences of points $P = [a, b, c, d]$ and $Q = [w, x, y, z]$. If we wish to create the diagonal pairs $[a, x]$, $[b, y]$ and $[c, z]$. We need the first three elements of $P$ and the last three element of $Q$. Or equivalently drop the first of one list, the last of another, and connect across using the lacing techniques we used for the regular frames.

     0  1  2  3  
P = [a, b, c, d]
      🡖  🡖  🡖
Q = [w, x, y, z]

# drop elements

P = [a, b, c, d]
      🡖  🡖  🡖
Q = [w, x, y, z]

# lace normally

P = [a, b, c]
     🡓  🡓  🡓
Q = [x, y, z]

The approach demonstrated uses the “split list” component to drop the first element of a sequence; and “shift list” to cycle one of the list backwards so as to drop its last element. There numerous ways to achieve the same result. Perhaps try using the “sub list” component, where you have to supply the start and end index of items to select. Meanwhile, the logic used here is captured in the diagram below:

     0  1  2  3  
P = [a, b, c, d] → cycle -1 → [d, a, b, c] → drop first → [a, b, c]
                                                           🡓  🡓  🡓
Q = [w, x, y, z] →                         → drop first → [x, y, z]

The approach of reshaping data such that they follow a convention, a certain form, required downstream is very common. Sometimes reshaping feels a bit like mental gymnastics, but the benefits of automated pair-wise lacing is too great to pass.

53KB

3B_Bridge-05.gh