British Museum Courtyard Parametric Modeling

British Museum Courtyard 

Parametric Modeling

ARCH 655

Introduction

The Great Court is the central square of the British Museum in London with a roof. It was redesigned in the 1990s by Foster and Partners, updating a previous design from the 1970s by Colin St John Wilson.

The center of the British Museum, once a hidden garden, has been transformed. After the British Library moved, the old book storage was removed, making room for a new public space that helps people get around the busy museum. Now, there's a big covered courtyard that connects different galleries. It has a shop, cafe, and the Reading Room, which is now open to everyone. Underneath, there are galleries, an education center, and student facilities. The courtyard's special roof keeps the building cool and bright. This renovation also helps connect nearby streets and public areas, improving London's walkways.

The court has a tessellated glass roof, covering the entire court, and surrounds the original circular British Museum Reading Room in the centre, now a museum. The glass and steel roof is made up of 4,878 unique steel members connected at 1,566 unique nodes and 1,656 pairs of glass windowpanes making up 6,100 m2 of glazing each of a unique shape because of the undulating nature of the roof.

https://www.fosterandpartners.com/projects/great-court-at-the-british-museum

https://www.fosterandpartners.com/projects/great-court-at-the-british-museum

My design modification involved changing the ceiling pattern, and I used an AI tool like DALL-E to generate images reflecting my design intent

Step 1: Creating surrounding mass

I began by modeling the base, which includes the surrounding buildings and a dome in the center. To do this, I created a set of boundaries and then extruded them to the desired height. Next, I used a circular curve to create the dome. As shown in the diagrams, I offset the circle inward and then moved it to the top. Using the loft component, I created a curved surface for the dome. (Figure1)

Figure 1

Step 2: Creating the initial surface

I Start with a rectangle and a circle. Divide each shape into eight sections to create surfaces between them. Place eight points on each edge and connect them to form a surface as shown in Figure 2.

Figure 2

Step 3: Creating mesh and shape of the ceiling 

I aimed to turn eight surfaces into meshes to form a single, curved mesh for the ceiling. I discovered that using a Kangaroo component helps turn flat surfaces into a bumpy, curved shape. 

I used Kangaroo2 to turn the flat mesh into a curved shape. First, I turned the edges of the mesh into springs to make them stretchy. Then, I added upward forces to certain points, pulling them in the Z direction to create a dome-like curve. I anchored the mesh at specific points around the outer edges to keep it in place.(Figure 3)

Figure 3

Finally, I Merged everything for the input of the Bouncy Solver in Kangaroo, which transformed the flat mesh into a curved surface, like a stretched and puffed-up fabric. (Figure 4)

Figure 4

Step4: creating Dimond pattern

Some paneling components enable the creation of diamond patterns; however, these components require a grid input. This necessitated the conversion of my mesh system into a grid format. To achieve this, I utilized the WarpWeft function from Kangaroo to extract the U and V lines from my mesh. Subsequently, I defined them as separate groups of curves. However, when I attempted to convert these curves into a grid and then into a diamond pattern, the output was distorted and disorganized, as illustrated in Figure 5.

Figure 5

Upon investigating the reason, I discovered that the curves from my model were not properly ordered. Therefore, I need to first organize the curves and then supply the ordered grid to the diamond pattern component. ( Figure 6)

Figure 6

In the end, by using the Mesh Pipe, I turned all these diamond-shaped lines into a frame for the ceiling. ( Figure 7)

Figure 7

Final Project

Parametric Modeling
British Museum courtyard

My goal is to transform the ceiling pattern design into a gradual sequence of hexagonal patterns. That's why I divide my work into multiple portions. One is to construct each hexagonal on top of a progressively larger design that spans the ceiling. Creating hexagons based on that gradual sequence is the second stage.

In the continues of previous work, I have a set of curves that I use as my starting point: 

First, to create a gradual sequence in Grasshopper I started with writing code in Python. For that purpose, I write a Python script that creates a geometric sequence, which is then normalized by scaling its values between 0 and 1 according to how much of the maximum value in the sequence they represent.

sequence = []
current = start
for _ in range(count):
    sequence. append(current)
    current *= factor

This loop runs “count” times. Every time, the current value of the “current” is appended to the sequence, and the “current” is then multiplied by a factor to obtain the next value. This produces a geometric sequence in which every phrase is the product of its preceding term and a constant factor. Then Find the Minimum Value in Sequence:

min_num = min(sequence)

Here, each member of the sequence has been removed from its minimum number (min_num) to modify it. This translation guarantees that the new sequence's lowest number is 0.

sequence = [i - min_num for i in sequence]

 identify the largest number in the translated sequence: 

max_num = max(sequence)

now I need to normalize the sequence, for that purpose, the values between 0 and 1, divide each element in the sequence by max_num. There is a new list called “a” that contains this normalized sequence.

a = []
for i in sequence:
    a.append(i/max_num)

Total_len is multiplied by each normalized value to scale it. The final values, which represent a series of lengths that scale proportionately within the entire requested length total_len, are saved in the list lens.

lens = []

for i in a:

    lens.append((i * total_len))

then I use the flip component to change the start point of my sequence because by default it is used from the end of the sequence. Next, I employ the evaluate component to identify points on curves, followed by using the dispatch function to categorize the line into two separate lists.

To create hexagons, I first translate their geometry into points, establishing how they connect by organizing them into a data tree structure in Python. (Figure 2)

Figure 3&4 illustrates how the hexagons are made up of repeated lines that form patterns. Horizontal lines that represent my curves are divided into two groups. In the first set, for example, the hexagons are divided into five equal parts, resulting in six points per hexagon. I created a new Python script by using the relationships found in the iterations of the points.

I was able to use the functions of the Grasshopper Python library directly in a script by using its components, which are represented as "gh". Also, initialize three empty lists to store different groups of values or objects.

from ghpythonlib import components as gh

list_1 = []

list_2 = []

list_3 = []

The script loops through an iterable or list called “x”. To obtain both the index i and the value j at that index, use the enumerate function: 

• If the index i is divisible by 6 (every sixth element, starting with the first), j is added to list_1.
• If the remainder of the index i when divided by 6, further divided by 4 equals 0 (positions 4 and 10 within every 12 elements sequence), j is added to list_2.

for i, j in enumerate(x):
    if i % 6 == 0: list_1.append(j)
    elif (i % 6) % 4 == 0: list_2.append(j)

By putting the first entry at the end of the list and rotating the list from one position to the left, this line rearranges list_1:

temp_list = list_1[1:] + [list_1[0]] 

For each element in list_2, the script creates a line from that element to the corresponding element in temp_list (the rotated version of list_1):

for i in range(len(list_2)):
    list_3.append(gh.Line(list_2[i], temp_list[i]))

 The gh.Line function from Grasshopper, which produces a line object between two points or similar constructs, is used to make these lines. List_3 contains the line objects.

Now I have the script for the set of lines A, for the set of lines B I would use the same approach but with a different relation between points to create another Python script. 

list_1 = []

list_2 = []

list_3 = []

for i, j in enumerate(x):

    if (i-1) % 6 == 0: list_1.append(j)

    elif ((i-1) % 6) % 2 == 0 and ((i-1) % 6) % 4 != 0:

        list_2.append(j)

Three lists are initialized for storing different types of data or objects. Then create a loop that iterates over a variable “x”. The index i is adjusted by subtracting 1, meaning the calculations are effectively for 0-based indexing being treated as 1-based. 
Append to list_1 if the adjusted index (i-1) modulo 6 equals 0, it selects every 6th element starting from the first (1, 7, 13, ... in 1-based counting). 
The element is added to list_2 if (i-1) % 6 gives a remainder of 2 or 4. Specifically, this condition selects every third and fifth element out of each group of six, starting from 1 (e.g., 3, 5, 9, 11, ... in 1-based counting).

for i in range(len(list_2)):

    list_3.append(gh.Line(list_1[i], list_2[i]))

This loop creates lines from each corresponding pair of elements in list_1 and list_2. The line objects are generated using gh.Line, a Grasshopper function creates a line between two points or geometrical constructs. These lines are stored in list_3.
It's now time to connect these points using the 'Line' component in Grasshopper. To ensure accurate connections, I will utilize the 'Shift' component to rearrange the order within my data tree. After establishing the lines, merging them into a single component allows me to apply the 'Mesh Pipe' command to generate a gradual hexagonal pattern on the ceiling. (Figure 5&6)

Figure 5