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.
Reconfigurable Domes
Computational design of dry-fit 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 difficult to replicate with-
out specific 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
different types of geometries is the inspiration be-
hind the proposed generative method as it takes into
consideration the force flows through the topologi-
cal connections of said modules (Chassagnoux 1970).
Additionally, the different 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
specifies 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-
fit, 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 specification 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 specified 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 different potential meth-
ods for creating the modules, three main criteria are
identified as priorities for the design to accomplish.
The first 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 final 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 floor 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 flow 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-fit systems incorporate structural evalu-
ation in their design to confirm 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 fit system.
However, both exemplify the spectrum of dry-fit 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 effort to create structural muqarnas, re-
ferred to as “genuine” muqarnas by Yaghan in his pa-
per “Self-Supporting Genuine Muqarnas Units”, the
first 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 figure. 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 first of the design criteria. This
method is based on a simplification 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 different 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 different 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 different logics to generate geometries in a gen-
eralized workflow. 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 final
criteria of structural self-sufficiency is all that remains
for this method to fulfill all three design criteria.
Simple orthogonal extrusions of the triangles
confirms that the variability is preserved in the 3-
Dimensional (3D) form, however the structural crite-
ria remains unfulfilled. 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 fulfils the structural
design criteria.
FRAMEWORK
Traditionally, muqarnas are superficial 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 final 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 workflow in the following order: construc-
tion of the Penrose pattern, sorting the modules to
model the topological structure of the pattern, iden-
tification of the rings in the topological structure,
navigation of the pattern, and finally 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 figure
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, figure 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 figure 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, figure 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 (figure 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 defined 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 fig-
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 figure 8 can help to visu-
alize the sorting code.
Next, the deg values are defined 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 figure 9. All triangles are
first 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 define
one of those triangles as an angled piece and the
other as a flat piece (algorithm in figure 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 flat piece and
an angled piece. The flat 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 defined as the flat 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, flat
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 first 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-
fies those triangles in the list tris_leveled. The next
step is to take the first 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 different
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
figure 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 redefined 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 flat 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 flat
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 final
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 figure 12.
Flat Piece. A similar yet simpler process constructs
the flat pieces of the modules. For the flat 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 flat piece. The resultant
flat portion of the module is shown in the bottom se-
quence of images in figure 12.
Displacement of the Modules. The displacement of
the modules is performed in the negative z-direction,
due to the overall methodology first addressing ge-
ometries near the pattern centroid and progressing
outwards.
The flat and angled pieces are displaced indi-
vidually by the same distance. The adjusted levels
list is used in order to define the magnitude of the
displacement, and all geometries are moved accord-
ingly. The method of stacking can be seen in figure
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 first 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-finding 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 different
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-fit blocks. Additionally, a fur-
ther generalization of the method has the potential
to produce re-configurable 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 significance. 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-fit, 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 superficially 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 figure 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 infinity’, 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, Definition 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
