Content uploaded by Pirouz Nourian

Author content

All content in this area was uploaded by Pirouz Nourian on Aug 16, 2021

Content may be subject to copyright.

Reconﬁgurable Domes

Computational design of dry-ﬁt blocks for modular vaulting

Selina Bitting1, Shervin Azadi2, Pirouz Nourian3

1,2,3Delft University of Technology

1s.bitting@student.tudelft.nl 2,3{s.azadi-1|p.nourian}@tudelft.nl

In contrast to the contemporary aesthetic account, Muqarnas are geometrically

complex variations of Squinches used for structural integration of rectilinear

geometries and curved geometries. Inspired by the historical functionality of

Muqarnas, we present a generalized computational workflow for generating

dry-fit stacking modules from two-dimensional patterns in order to construct a

dome. Similar to Muqarnas these blocks are modular in nature, complex in

geometry, and compression-only in their structural behavior. We demonstrate the

design of such structures based on the exemplary Penrose pattern and showcase

the variations & potentials of this method in comparison to conventional

approaches.

Keywords: Muqarnas, Generative Design, Modular Design, Unreinforced

Masonry Architecture, Penrose Tiling, Workflow Design

INTRODUCTION

Muqaranas (Tabbaa 1985) are an archetype of the

middle-eastern architectural vernacular, often recog-

nized by their intricate design. They are created using

various modules, and are diﬃcult to replicate with-

out speciﬁc knowledge and materials due to their

intricacy as well as the relevant construction tech-

niques. Muqarnas originated as a structural method

for transitioning from a rectilinear space to a dome, as

a geometrically more complex squinch (Koliji 2012).

This method of using modules to transition between

diﬀerent types of geometries is the inspiration be-

hind the proposed generative method as it takes into

consideration the force ﬂows through the topologi-

cal connections of said modules (Chassagnoux 1970).

Additionally, the diﬀerent techniques used to under-

stand and replicate traditional muqarnas are essen-

tial to the generalization of the construction method

into a computational process.

Traditionally, muqarnas use a pattern which

speciﬁes the juxtaposition of modules in the hori-

zontal plane. By reading the pattern, it is apparent

which modules are located where in order to create

the overall dome or squinch (Yaghan 2001, [4] ). This

relationship between pattern and block is replicated

in the computational process which results in a dry-

ﬁt, pre-cast set of interlocking blocks that are held to-

gether via gravity; thus resulting in a compression-

only structure. In order to translate the muqarnas

into such a method, two vital elements are required:

a 2D pattern and a speciﬁcation of how the blocks re-

late to the pattern.

The generative method (see Algorithm 1 in Fig-

ure 1) begins with the creation of a Penrose pattern

Computational design - Volume 1 - eCAADe 39 |263

Figure 1

Computational

Muqarnas

Procedure

[2], then navigates the pattern, and later extrudes

the modules. The Penrose pattern is exemplary, but

any other 2D pattern can be utilized instead (Castera

2003). This speciﬁed relationship between the pat-

tern and the block results in a system of overlapping,

stacked modules with an overall design that is indica-

tive of traditional muqarnas (Sakkal 1988), but is gen-

eral in its implementation. The modules are simple

enough in design to be constructed with neither par-

ticular knowledge about materiality nor additional

equipment.

In order to evaluate the diﬀerent potential meth-

ods for creating the modules, three main criteria are

identiﬁed as priorities for the design to accomplish.

The ﬁrst is to limit the number of distinct modules

to a maximum of 20, and the second is to obtain the

maximum amount of variation using these modules.

This variation should result in an interesting pattern

that has a similar aesthetic to the original muqarnas.

The ﬁnal criteria is that the method of construction

be simple enough for a person to build it themselves,

which therefore rules out structural systems in which

one block is held in place by neighboring blocks, as

one example, to instead favor stacking methods.

The motivation behind the proposed computa-

tional method presented in this paper is to explore

and validate the feasibility of procedural design of

muqarnas-like discrete blocks for low-tech modu-

lar construction of vaults/domes by means of dry-

stacking. The remainder of the paper presents an ex-

emplary implementation of a reproducible method

for generating the 3D geometry of the blocks based

on a Penrose tiling (a 2D tessellation) of the ﬂoor plan

of the dome to be muqarnas-vaulted, based on the

following meta-procedure:

BACKGROUND

Domes present a number of challenges to modular-

ization in that while they are constructed out of stan-

dard bricks or stone blocks, successfully doing so re-

quires expert knowledge of how to achieve strength

and stability through ad hoc placement of bricks.

Therefore a dome structure is either constructed by a

highly skilled mason or imitated through some other

material such as steel. Incorporating the structural

performance in a computational method allows the

block geometries to account for the ﬂow of forces in

the dome and to design a stacking system that ac-

complishes a similar form that is easy to construct. By

doing so the process can be expanded to shapes that

are not just circular domes but can also replicate tran-

sitional spaces such as squinches.

In contrast to conventional bricklaying methods,

existing dry-ﬁt systems incorporate structural evalu-

ation in their design to conﬁrm their validity, rather

than gluing blocks together or using a mortar be-

tween them. Two such examples are the Armadillo

Vault constructed by the Block Research Group (BRG)

of ETH Zurich [5] and Block Moulds [6]. The Armadillo

Vault is a complex example whereas Block Moulds is

a more practical implementation of a dry ﬁt system.

However, both exemplify the spectrum of dry-ﬁt sys-

264 |eCAADe 39 - Computational design - Volume 1

tems and how simple or complex constructions can

become relatively easy to construct and possible to

disassemble.

In an eﬀort to create structural muqarnas, re-

ferred to as “genuine” muqarnas by Yaghan in his pa-

per “Self-Supporting Genuine Muqarnas Units”, the

ﬁrst option is to use a radial method of creating

blocks. Figure 2 shows the radial slicing in both plan

and section, which leads to a basic block as shown

in the same ﬁgure. The next step is to carve or add

to the inner face of this block in order to make a pat-

tern reminiscent of traditional muqarnas. However,

due to the varying radii as slices are made along with

the dome, this method results in far too many mod-

ules and thus fails the ﬁrst of the design criteria. This

method is based on a simpliﬁcation of the method

used by Yaghan which is an early example of gener-

ating genuine muqarnas computationally.

Figure 2

Diagram of the

radial approach.

The second option is to use a stacking method de-

rived a careful study of the vaulted dome of the

“Masjed-e Jameh mosque” (Friday mosque) in Isfa-

han, Iran. The repeating shapes of the stone are sim-

ple and serve a structural purpose. These shapes

are created using multiple simple, rectangular bricks.

The main downfalls of this precedent are that it func-

tions at a very large scale and that the system is not

compression-only. A projected 2-Dimensional (2D)

pattern of the Friday mosque dome demonstrates

how each block sits over the top of a gap, showing

that this design results in areas of tension. This in-

dicates that it is not optimized for a structure com-

prised of only masonry.

A diﬀerent approach to generating muqarnas

is presented in Alaçam (Alaçam and Güzelci 2016)

where the outline of the space is used to develop a

plan projection. The pattern is generated by subdi-

viding this outline into triangles. Afterwards, a sur-

face is produced corresponding to the plan. This

is a diﬀerent approach which does not result in 3D

blocks, and would therefore require additional steps

to transition from a surface to modules.

The 2D pattern of the stacking approach resulted

in a realization that virtually any pattern on the 2D

plane can be navigated to generate block forms. In

investigating the viability of this approach, a third

option emerged. This option is to traverse patterns

with diﬀerent logics to generate geometries in a gen-

eralized workﬂow. The Penrose Pattern emerges

as a promising pattern to couple with this pattern-

navigating its 5-fold symmetry and lack of repeti-

tion. However, the entire pattern consists of only

two types of triangles: kites and darts (Gardner 1989).

This inherent modularity of the pattern meets the de-

sign criteria for modularity and variability, so the ﬁnal

criteria of structural self-suﬃciency is all that remains

for this method to fulﬁll all three design criteria.

Simple orthogonal extrusions of the triangles

conﬁrms that the variability is preserved in the 3-

Dimensional (3D) form, however the structural crite-

ria remains unfulﬁlled. This method is therefore ac-

cepted as the most promising approach, and the next

challenge is to navigate the pattern in a way that pro-

duces a free-standing form which fulﬁls the structural

design criteria.

FRAMEWORK

Traditionally, muqarnas are superﬁcial rather than in-

tegrated structural elements of a building commonly

made of wood or stucco. The blocks are then essen-

tially “glued” to the building via additional stucco or

nails (Yaghan 2007) according to a 2D plan projec-

tion, which is the same process as with their structural

counterparts. The computational method focuses on

this particular element to expand and generalize the

process in order to generate any number of patterns

or tessellations into domes, or possible vaults.

Computational design - Volume 1 - eCAADe 39 |265

Within the scope of this paper, we assume that

the ﬁnal form is a dome-like structure, with the outer

ring as the main support and the apex in the center.

Consequently, the symmetry of the Penrose Pattern

becomes an advantage for this input condition.

METHODOLOGY

In this section we will present the details of the com-

putational workﬂow in the following order: construc-

tion of the Penrose pattern, sorting the modules to

model the topological structure of the pattern, iden-

tiﬁcation of the rings in the topological structure,

navigation of the pattern, and ﬁnally construction of

the 3D mesh of each one of the modules. The inher-

ent modularity and variability of the Penrose Pattern

prove it to be favorable, as it provides a limited set of

modules while preserving the variety in the designs.

Each structural module is constructed out of two tri-

angular tiles in the Penrose pattern to ensure stack-

ability. The pattern is navigated from the outermost

edges to the centroid in order to create pairs of trian-

gles. This logic allows modules to overlap, and there-

fore support each other structurally.

Step One: Pattern Generation

The initial step is to dynamically generate a Penrose

Pattern. Given a diameter, the number of subdivi-

sions, and the number of sides to the initial polygon,

an initial set of acute triangles are created (see ﬁgure

3)

Figure 3

Generated Penrose

pattern subdivision

method illustrated.

ϕ=1 + √5

2(1)

The algorithm which performs this function is largely

based on a python script previously written by Josh

Preshing [1]. Within his implementation, triangles

have two options for color: red and blue. Red indi-

cates an acute triangle and blue indicates an obtuse

triangle. The algorithm also stores the triangle cor-

ners as complex numbers, which contain the infor-

mation of the (x, y)coordinates for each of the cor-

ners A,B, and C. These coordinates are stored as

python complex numbers, meaning that the imagi-

nary value of Acorresponds to it’s xcoordinate, and

the real value corresponds to it’s ycoordinate. The

following shows the tuple with all subsequent infor-

mation:

(color, A, B, C )(2)

For the creation of a dome, the number of subdivi-

sions is set equal to 5, the diameter is equal to 6.6

meters, and the number of sides is equal to 10. The

algorithm stores the triangles as complex numbers

in creating the acute triangles, to then perform the

subdivision algorithm with those triangles using an

algorithm which subdivides an input triangle by the

golden ratio ϕ, and then appends the relevant data,

(color, A, B, C), of the newly generated triangles to

the results and outputs the list of all the newly sub-

divided triangles.

Algorithm 2, ﬁgure 4, begins with creating a poly-

line that connects the three corners of the triangle.

Then the centroid of the triangle is found using to fol-

lowing equation [3]:

Ox=Ax+Bx+Cx

3Oy=Ay+By+Cy

3

(3)

This centroid is essential to understanding the lo-

cation of the triangle in relation to the center of the

overall pattern. The distance to the center of the pat-

tern provides a method of constructing a triangula-

tion between the centroid of the pattern, the cen-

troid of the triangle, and the horizontal seam in the

266 |eCAADe 39 - Computational design - Volume 1

Figure 4

Triangle Data

Algorithm

pattern (as can be seen in ﬁgure 5), to then locate the

triangles in relation to one another. The arcsin and

arccos provide the information needed to sort trian-

gles radially counterclockwise starting at the seam in

the pattern, which is performed in the following step

of the code.

Figure 5

Diagram of the

triangle sorting.

Computational design - Volume 1 - eCAADe 39 |267

Figure 6

Triangle Sorting

Algorithm

268 |eCAADe 39 - Computational design - Volume 1

Figure 7

Pattern Navigation

Algorithm

Step Two: Triangle Sorting

The values of the distances along with the arcsin and

arccos are the inputs to algorithm 3, ﬁgure 6, which

gives priority to the sorting method. In this algo-

rithm, distance has higher importance than angle

(dw > aw), which allows the sorting of the individ-

ual triangles to be from the center of the pattern to

the outside, as well as counterclockwise from the hor-

izontal seam on the right (ﬁgure 5).

For the organization portion, the algorithm uses

the information previously appended to tri_info in or-

der to locate the points radially. These values are con-

verted to degrees, and then ranges are deﬁned in or-

der to determine in what quadrant of the circle the

Computational design - Volume 1 - eCAADe 39 |269

triangle is located. To elaborate, the domains of arc-

sin and arccos are shown below, and illustratedin ﬁg-

ure 8:

arcsin {x} ⇒ [π

2,−π

2](4)

arccos {x} ⇒ [0, π](5)

Figure 8

Diagram showing

the sorting of

calculated values

into circle

quadrants.

Associated with arcsin is the y-coordinate, and asso-

ciated with the xcoordinate is arccos. Therefore all

four quadrants of a circle are included by evaluating

them together. Referring to ﬁgure 8 can help to visu-

alize the sorting code.

Next, the deg values are deﬁned according to

which quadrant each triangle is, and thereafter each

triangle is sorted throughout the entire pattern ac-

cording to degrees and distance from the center.

Figure 9

Grouping triangles

into rings.

Step Three: Pattern Rings

Triangles equidistant from the center are located

within the same ring, see ﬁgure 9. All triangles are

ﬁrst sorted by indexing each triangle. Then the dis-

tance of the triangle prior and the current triangle to

the centroid are compared to determine if they are in

the same ring, in which case the index increases by 1.

Step Four: Pattern Navigation

The method developed for the pattern navigation is

to select a pair of adjacent triangles and then deﬁne

one of those triangles as an angled piece and the

other as a ﬂat piece (algorithm in ﬁgure 7). This pro-

cess is performed manually through trial and error, as

not all combinations allow the pairs to overlap in a

way which reaches the center of the pattern. Ideally

this process begins at the outer edge and works to-

ward the center until all shapes are incorporated in a

sequence.

A single module is comprised of a ﬂat piece and

an angled piece. The ﬂat piece is the largest part of

the module, best described as an orthogonal extru-

sion of the triangle. The angled piece is the part of

the module which is extruded to a point. The point

in question is the corner of the triangle closest to the

centroid of the pattern. The next pair of triangles

form the following module, wherein the current an-

gled piece becomes deﬁned as the ﬂat piece for the

next module and the next adjacent triangle is the an-

gled piece of the module, and so on and so forth until

the centermost triangles have been included in the

extrusion process to make modules. In this way, ﬂat

pieces sit overtop angled pieces, to form a system of

modules that stack and distribute their load down-

wards to the next module. The method is elaborated

upon in step six, where the modules are extruded.

The ﬁrst section of the algorithm iterates through

the rings such that each ring is given an index, and

the triangles within the ring are indexed as well. The

second section, for oin order, takes each pair in the

manually determined pattern navigation and identi-

ﬁes those triangles in the list tris_leveled. The next

step is to take the ﬁrst and second triangles and com-

270 |eCAADe 39 - Computational design - Volume 1

bine them together so that a triangle with index 0 of

level 0 is paired with the triangle of index 0 of level

1, and so on. The result is pairs of triangles that step

their way from the centroid out. Figure 10 shows one

of these ‘strings’ beginning at the outside of the pat-

tern and working its way inwards. Figure 11 shows

the adjacent ‘strings’ as well for context.

Figure 10

Plan showing a

singular string of

triangle pairs

progressing

towards pattern

centroid.

Figure 11

Plan showing

adjacent, shorter

strings.

Step Five: Adjustments for Triangle Dis-

placement

The ‘strings’ within the paired triangles have diﬀerent

quantities of modules. The steps in the process which

displace and extrude the modules rely on an initial

displacement of the triangles to their relevant dis-

tances from the top of the dome. This can be seen in

ﬁgure 10 where some strings extend from the outside

to the very center of the pattern. However, there is,

for example, a string that ends approximately three

rings from the top. This translates to:

z= 3 ·bH (6)

Therefore the values are manually redeﬁned so that

the associated index (i) of the strings accounts for

the distance from the top of the dome. This updated

value is instead stored as a new value, z, so that the

original iis not lost. The modules are then vertically

displaced according to this value.

Step Six: Module Extrusion

Each module, as explained before, consists of an an-

gled and a ﬂat piece. A for loop iterates through the

list of pairs to perform basic extrusions on the tri-

angles based on whether they are the angle or ﬂat

piece. R egardlessof the t ype of pieceassociated with

the triangle, the initial step is to retrieve the vertices

of the triangles.

Angled Piece. For the angled piece, the next step

is to sort the vertices and determine which vertex is

closest to the center of the pattern, now referred to

as the origin. The input for the getCorners function

is the polyline of the angled piece, and the output is

(cornerPoints[0],cornerPoints[1],minPoint) where min-

Point indicates the vertex closest to the origin.

This output provides the two inputs, (cor-

nerPoints[0],cornerPoints[1]), for the duplicatePoints

function. This function displaces the vertices verti-

cally by the block height (bH). This provides the ﬁnal

data needed to construct a vertical polyline rectangle

to be extruded toward the vertex closest to the origin.

This extrusion is performed in a loop that iterates over

the pairs of triangles. This concludes the process for

creating the angled portion of the module, visualized

in the top sequence of images in ﬁgure 12.

Flat Piece. A similar yet simpler process constructs

the ﬂat pieces of the modules. For the ﬂat piece an

arbitrary curve is used as the input for the ExtrudeCur-

veStraight function to produce an orthogonal extru-

Computational design - Volume 1 - eCAADe 39 |271

Figure 12

Diagram showing

the steps

performed by the

algorithm to

extrude the module

geometries.

sion. The initial step is to retrieve an arbitrary corner

using the function getOneCorner. Then, the function

duplicatePoint makes a duplicate point displaced by

block height bH. This results in the orthogonal line to

guide the extrusion of the ﬂat piece. The resultant

ﬂat portion of the module is shown in the bottom se-

quence of images in ﬁgure 12.

Displacement of the Modules. The displacement of

the modules is performed in the negative z-direction,

due to the overall methodology ﬁrst addressing ge-

ometries near the pattern centroid and progressing

outwards.

The ﬂat and angled pieces are displaced indi-

vidually by the same distance. The adjusted levels

list is used in order to deﬁne the magnitude of the

displacement, and all geometries are moved accord-

ingly. The method of stacking can be seen in ﬁgure

13 in order to clarify how the 2D plan translates to a

3D form. Figure 13

Diagram showing

three stacked

modules, and their

original geometries

projected below.

DISCUSSION & FUTURE WORK

An overarching element which the methodology

lacks is compatibility with a variety of inputs. The pro-

cess as exists at this stage, the inputs limit the variety

of results, which could otherwise expand in scope to

explore a variety of patterns and block shapes. The

traversal scheme, currently manual, is essentially rep-

resented with tree graphs. Thus, one future direc-

tion is to utilize graph traversal methods, particularly

breadth ﬁrst search, to pair triangles of the Penrose

pattern and generate modules.

Although the results show modules which can

be stacked and result in a free-standing dome, there

is no structural evaluation incorporated within the

methodology. This is an essential step to be incor-

porated in the future iterations of the methodology

as it represents a major hurdle to translating the gen-

erated scheme into a physical construction. Two op-

tions for enhancing this portion of the methodol-

ogy are the dynamic relaxation method [7] and the

force density method (Schek 1974), both of which are

form-ﬁnding methods which take the tessellated pat-

tern as a network and relax it under a set of forces un-

til it reaches equilibrium. Incorporating this step also

allows the modules to be reshaped in order to ap-

proximate a relaxed form which accommodates for

the material properties and structurally feasibility, ul-

timately optimising the form.

Figure 14 is our proposed meta-procedure for

topologically generalizing the proposed method so

that it can work on input shapes that are not neces-

sarily as symmetrical as the presented polygon.

272 |eCAADe 39 - Computational design - Volume 1

Figure 14

Road-map of

Computational

Muqarnas

Procedure

Figure 15

Views from below

of diﬀerent

generated domes.

The resultant blocks of this process will simplify and

optimize block construction methods. Dry stacking

modules allow for total demountability which is in

congruence with the intentions and goals of the cir-

cular construction practices. Circular spaces or tran-

sitions between rectilinear and circular spaces can be

generated with this modular method to provide the

easy to construct dry-ﬁt blocks. Additionally, a fur-

ther generalization of the method has the potential

to produce re-conﬁgurable vaulting systems (Alaçam

et al. 2017). As this methodology was initially de-

veloped in the context of the MSc EARTHY Studio

at TU Delft (Nourian et al. 2020), these blocks were

originally intended to be made of cast earth blocks.

Within that educational context, the main task was

to develop a low-tech construction process for the

domes of a heritage complex dedicated to Syrian her-

itage. Throughout the course it was determined that

exploring the intersect of muqarnas and computa-

tion would be aligned with the intention behind the

heritage complex. In designing the process which re-

sulted in this paper, it was further realized that this

process had the potential to be generalized and re-

formulated to qualify for other contexts based on the

variety of spatial quality that it can potentially spawn

and not just cultural signiﬁcance. Nevertheless, the

Computational design - Volume 1 - eCAADe 39 |273

methodology stays true to its origin as it is still com-

patible with using local material for manufacturing

the simple blocks that are not only circular as they are

dry-ﬁt, but also are aligned with the skill level of the

local workforces as their assembly process is based

on simply stacking them.

CONCLUSION

As opposed to traditional muqarnas modules which

are attached to the building superﬁcially for decora-

tion, these computationally generated modules are

produced for simplifying the construction process of

a masonry vault by making it easy for people with-

out sophisticated masonry skills to make complex

form active shells out of a few types of easily mass-

produced blocks. The proposed method relies upon

prescribed pattern navigation which relates to the

pattern navigation utilized in traditional muqarnas.

The method and the forms generated by it are there-

fore derivations of the traditional designs rather than

imitations, which was the original intention. A vari-

ety of designs are achieved, shown in ﬁgure 15, and

show great promise should the methodology be fur-

ther developed.

REFERENCES

Alaçam, S and Güzelci, O 2016 ’Computational Interpre-

tations of 2D Muqarnas Projections in 3D Form Find-

ing’, no source given

Alaçam, S, Güzelci, OZ, Gürer, E and Bacınoğlu, SZ

2017, ’Reconnoitring computational potentials of

the vault-like forms: Thinking aloud on muqarnas

tectonics’, International Journal of Architectural Com-

puting, 15(4), pp. 285-303

Castera, JM 2003 ’Play with inﬁnity’, Meeting Alhambra,

ISAMA-BRIDGES Conference Proceedings, pp. 189-196

Chassagnoux, A 1970, ’Persian vaulted architecture:

morphology and equilibrium of vaults under static

and dynamic loads’, WIT Transactions on The Built En-

vironment, 16

Gardner, M 1989, Penrose Tiles to Trapdoor Ciphers ...and

the Return of Dr.Matrix, The Mathematical Associa-

tion of America, Washington, DC

Koliji, H 2012, ’Revisiting the squinch: From squaring the

circle to circling the square’, Nexus Network Journal,

14(2), pp. 291-305

Nourian, P, Azadi, S, Hoogenboom, H and Sariyildiz, S

2020, ’EARTHY, Computational Generative Design

for Earth and Masonry Architecture’, RUMOER, pp.

47-53

Sakkal, M 1988, ’An introduction to Muqarnas domes Ge-

ometry’, Structural Topology 1988 núm 14

Schek, H.J. 1974, ’The Force Density Method for Form

Finding and Computation of General Networks’,

Computer Methods in Applied Mechanics and Engi-

neering, 3, pp. 115-134

Tabbaa, Y 1985, ’The Muqarnas Dome: Its Origin and

Meaning’, Muqarnas, 3, pp. 61-74

Yaghan, M 2001, ’The Muqarnas Pre-designed Erect-

ing Units: Analysis, Deﬁnition of the Generic Set of

Units, and a System of Unit-Creation as a New Evo-

lutionary Step’, Architectural Science Review, 44, pp.

297-318

Yaghan, DMA 2007, ’Self-Supporting Genuine Muqarnas

Units’, Architectural Science Review, 48(3), pp. 245-

255

[1] https://preshing.com/20110831/penrose-tiling-expl

ained/

[2] https://www.maths.ox.ac.uk/node/865

[3] www.mathopenref.com/pageurl.html

[4] http://www.shiro1000.jp/muqarnas/default-.htm

[5] https://block.arch.ethz.ch/brg/

[6] https://www.blockmoulds.com/

[7] https://github.com/Pirouz-Nourian/VectoRelax_Vec

torized_Dynamic_Relaxation/tree/v1.3

274 |eCAADe 39 - Computational design - Volume 1