10.014 CTD
  • Overview
  • Schedule
  • Administrative
    • Accessing Rhino remotely
    • Rhino for Mac
  • ASSIGNMENTS
    • Dates and rubrics
    • Generative design
      • Generative design
    • Parametric design
      • Parametric design
    • Simulated design
      • Simulated design
      • Simulated design
  • SESSION 1B
    • Computer Aided Design
    • Ranges and expressions 1
      • Ranges and expressions 2
      • Ranges and expressions 3
      • Ranges and expressions 4
      • Ranges and expressions 5
      • Ranges and expressions 6
  • SESSION 2A
    • Visual programming 1
      • Visual programming 2
      • Visual programming 3
      • Visual programming 4
    • Associative modelling 1
      • Associative modelling 2
      • Associative modelling 3
  • SESSION 2B
    • Logical Patterns 1
      • Logical patterns 2
      • Logical patterns 3
  • SESSION 3A
    • Spatial geometry 1
      • Spatial geometry 2
      • Spatial geometry 3
      • Spatial geometry 4
      • Spatial geometry 5
      • Spatial geometry 6
      • Spatial geometry 7
    • Curve geometry 1
      • Curve geometry 2
      • Curve geometry 3
      • Curve geometry 4
  • SESSION 3B
    • Surface geometry
    • Parametric modelling 1
      • Parametric modelling 2
      • Parametric modelling 3
      • Parametric modelling 4
  • SESSION 4A
    • Information nesting 1
      • Information nesting 2
      • Information nesting 3
    • Data landscapes 1
      • Data landscapes 2
      • Data Landscapes 3
      • Data landscapes 4
  • SESSION 4B
    • Mesh geometry 1
      • Mesh geometry 2
      • Mesh geometry 3
  • SESSION 5A
    • Space and time 1
      • Space and time 2
    • Modelling entities 1
      • Modelling entities 2
      • Modelling entities 3
  • SESSION 5B
    • Multibody dynamics 1
      • Multibody dynamics 2
    • Material elasticity 1
      • Material elasticity 2
      • Material elasticity 3
  • SESSION 6A
    • Form-finding 1
      • Form-finding 2
      • Form-finding 3
      • Form-finding 4
  • SESSION 6B
    • AI Image generation 1
      • AI Image generation 2
      • AI Image generation 3
  • APPENDIX
    • Spirograph 1
      • Spirograph 2
    • Curves
    • Swarm Intelligence 1
      • Swarm Intelligence 2
    • Hybrid programming 1
      • Hybrid programming 2
Powered by GitBook
On this page
  • Spine Geometry
  • Rotating about the Spine
  • Rotating Frame Points
  • Centreline Geometry
  • Diagonal Bracing
  1. SESSION 3B

Parametric modelling 1

Helix bridge

PreviousSurface geometryNextParametric modelling 2

Last updated 8 months ago

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:

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.

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]o=[0, 0, 0]o=[0,0,0], x=[1,0,0]x=[1, 0, 0]x=[1,0,0], y=[0,1,0]y=[0, 1, 0]y=[0,1,0] and z=[0,0,1]z=[0, 0, 1]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]p=[1, 2, 3]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∗zp = o + 1 * x + 2 * y + 3 * zp=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]p = [0, 0, 0] + 1.0 * [1, 0, 0] +2.0 * [0, 1, 0] +3.0 * [0, 0, 1]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]p = [0, 0, 0] + [1, 0, 0] + [0, 2, 0] + [0, 0, 3]p=[0,0,0]+[1,0,0]+[0,2,0]+[0,0,3]

or finally p=[1,2,3]p = [1, 2, 3]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∗bp’ = q + 1 * t + 2 * n + 3 * bp’=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)∗bp’ = q + r * cos( c * s + p ) * n + r * sin( c * s + p ) * bp’=q+r∗cos(c∗s+p)∗n+r∗sin(c∗s+p)∗b

where rrr is the radius of the circle, ccc “c” is the cycles around the circle, ppp is the phase, or starting angle, around the circle and sss is the parameter along the circle.

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.

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]    ┘

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]P = [a, b, c, d]P=[a,b,c,d] and Q=[w,x,y,z]Q = [w, x, y, z]Q=[w,x,y,z]. If we wish to create the diagonal pairs [a,x] [a, x][a,x], [b,y] [b, y][b,y] and [c,z] [c, z][c,z]. We need the first three elements of PPP and the last three element of QQQ. 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.

>
Cox Architects
20KB
3B_Bridge-01.gh
24KB
3B_Bridge-02.gh
55KB
3B_Bridge-03.gh
56KB
3B_Bridge-04.gh
53KB
3B_Bridge-05.gh
Drawing
Drawing