See discussions, stats, and author profiles for this publication at: https://www.researchgate.
net/publication/384401316
FORM-FINDING OF ARCHES
Article in Journal of Applied Sciences-SUT · September 2024
DOI: 10.62792/ut.jas.v10.i19-20.p2745
CITATIONS READS
0 47
4 authors, including:
Teodora Mihajlovska Liljana Dimevska Sofronievska
Saints Cyril and Methodius University of Skopje Saints Cyril and Methodius University of Skopje
12 PUBLICATIONS 3 CITATIONS 20 PUBLICATIONS 5 CITATIONS
SEE PROFILE SEE PROFILE
All content following this page was uploaded by Liljana Dimevska Sofronievska on 18 March 2025.
The user has requested enhancement of the downloaded file.
XXVIII KONGRES DIMK I IX KONGRES SIGP SA
IMEĐUNARODNIM SIMPOZIJUMOM O ISTRAŽIVANJIMA I
PRIMENI SAVREMENIH DOSTIGNUĆA U GRAĐEVINARSTVU
U OBLASTI MATERIJALA I KONSTRUKCIJA
Ana Trombeva-Gavriloska1, Teodora Mihajlovska2 , Liljana Dimevska Sofronievska3
PARAMETRIČKI ALGORITAM ZA ODREĐIVANJE OBLIKE DVOSLOJNIH
LJUSKI PODLOŽNIH SEIZMIČKOM OPTEREĆENJU
Rezime: Kada su izložene horizontalnim seizmičkim silama, geometrija ljuski igra ključnu ulogu u
njihovom ponašanju, prvenstveno zbog njihove lake mase i velike geometrijske krutosti.
Dosadašnja istraživanja su pokazala da se definicija oblika ljuski zasniva na trodimenzionalnim
mrežastim modelima dobijenim pomoću algoritama dinamičke relaksacije, uzimajući u obzir
sopstvenu težinu ljuske i horizontalnu seizmičku silu koja deluje u najmanje dva ortogonalna
pravca. Primenom ovog pristupa dobija se geometrija jednoslojne ljuske promenljive debljine ili
geometrija dvoslojnih međusobno povezanih tanjih i lakših ljuski. U radu je prikazan metod
dinamičke relaksacije primenom softverskog paketa Rhinoceros 3D. Implementacija ovakvog
metoda u specifičnom softverskom paketu bi omogućila arhitektama, u ranoj fazi projektovanja, da
definišu formu koja ima poboljšane performanse pod dejstvom seizmičke sile.
Ključne reči: dvoslojne ljuske; seizmički dizajn, parametarski dizajn, dinamička relaksacija
PARAMETRIC ALGORITHM FOR FORM-FINDING OF DOUBLE-LAYERED
SHELLS SUBJECTED TO SEISMIC LOADING
Resume: When subjected to horizontal seismic forces, the geometry of the shells plays a key role in
their behavior, primarily due to their light mass and high geometric rigidity. Previous research has
shown that definition of the shape of shells is based on three-dimensional mesh models obtained
through dynamic relaxation algorithms, taking into account the shell's own weight and the
horizontal seismic force acting in at least two orthogonal directions. Applying this approach, the
geometry of a single-layer shell with variable thickness or the geometry of two-layer
interconnected thinner and lighter shells is obtained.This paper presents the method of dynamic
relaxation using the Rhinoceros 3D software package.. The implementation of such a method in the
specific software package would allow architects, at an early stage of design, to define a form that
has improved performance under the action of seismic force.
Keywords: double-layered shells; seismic design, parametric design, dynamic relaxation
1 Professor, Ph.D., Faculty of Architecture, “Ss. Cyril and Methodius” University,
agavriloska@arh.ukim.edu.mk
2 Teaching assistant, M.Arch, Faculty of Architecture, “Ss. Cyril and Methodius” University,
mihajlovska.teodora@arh.ukim.edu.mk
3Teaching assistant, M.Arch, Faculty of Architecture, “Ss. Cyril and Methodius” University,
dimevska.liljana@arh.ukim.edu.mk
1. INTRODUCTION
When considering horizontal seismic forces, the geometry of shells plays a key
role in their behavior, primarily due to their light mass and great geometric stiffness.
Nevertheless, seismic loading is rarely taken into account in the initial design of shells,
although it could significantly improve material efficiency and seismic performance. In
recent research, methodologies have been developed that generate forms for shells
designed to carry their own weight and seismic load through 3D models of suspended
networks of cables obtained by implementing a dynamic relaxation method [1]. By
applying this approach, the geometry of a single-layered shell with variable thickness or
the geometry of two-layer interconnected thinner and lighter shells is defined.
The aim of this research is the implementation of the method in a software that
allows great flexibility in the creation of 3D models and is used in the early stages of the
design during the genesis of the very form of architecture. Rhinoceros3D [2], through its
Grasshopper virtual programming environment, is used mainly for parametric design. In
this paper, the application of the method in the Rhinoceros 3D software package is
presented. Through implementation in the virtual programming environment Grasshopper
and the programming language Python, an algorithm is built, which, for a given layout
shape, defined boundary conditions and seismic force intensity, generates a double-layer
shell. Dynamic relaxation is performed using Kangaroo [3], which is an integrated plug-
in in Grasshopper, after which the proposed algorithm from the obtained shells of
different load cases defines the envelope of the double shell.
The algorithm is a visual algorithm developed through Grasshopper, based on the
principle of components and connections between them. Grasshopper components are
preprogrammed, ready-made segments of code that perform specific tasks. Such
components connect with each other to build an algorithm that performs the desired task.
However, not all necessary functions are available as ready-made components, certain
specific functions must be written as classical code, through a programming language.
This code is entered as a new component that builds on the visual algorithm.
Developing methods within this framework means that the form that this research
examines in terms of its bearing characteristics, through the same 3D model, can be
further considered in terms of various parameters that are of interest to the designer.
2. OBTAINING INDIVIDUAL SHELLS BY DYNAMIC RELAXATION
METHOD (VISUAL ALGORITHM)
In order to obtain the envelope of a double shell, first the individual shells of
different load cases are defined. In this research, 5 different load cases were taken into
consideration: a load case representing gravity loading without any horizontal
acceleration and 4 combinations of gravity and horizontal seismic acceleration in both
orthogonal directions, in the positive and negative directions with an acceleration
intensity of 0.45g.
The algorithm used by Kangaroo to perform the operation is a form of dynamic
relaxation, a numerical method based on solving a set of nonlinear equations. Dynamic
relaxation follows the movement of the structure over time at a given loading and just
like the Verlet method [4], it is used to integrate Newton's second law over time [5].
Figure 1 Overlapping of the shells obtained by modeling with different loading cases
By combining all the forces acting on each point, the equilibrium is determined by
the constant displacement of all points through several iterations until the forces are
balanced and the movement stops, that is, until the structure stops in static equilibrium.
This happens in a dynamic way so that the motion will oscillate around the equilibrium
and damping is used to remove the energy and ensure convergence. In typical
engineering applications of dynamic relaxation, the desired output is a static equilibrium
configuration for given boundary conditions.
In the this case study, a square base is taken that rests on pined supports at its
corners, which is divided into 10 x 10 mesh in Grasshopper. In this implementation, the
shell surface is represented digitally by discretizing the surface into a network of linear
elastic springs connected at nodes with free rotation. Gravity and earthquake
accelerations (a) are applied to each node, generating loads. The discretized model is
given to the Kangaroo solver which models the shells by way of dynamic relaxation. The
resulting model behaves like a cable net that stands in pure compression under a
combined loading of gravity and horizontal acceleration, as it is the inverse of a net that
hangs in pure tension under such loading.
The process of modeling the shell is entirely performed in the Grasshopper virtual
environment and is an algorithm created through the visual programming language of the
same name. The shells obtained in this way represent input information for the algorithm
which generates the envelope of the double layered shell as output information.
Considering that the specific functions needed to generate the envelope are not available
in Grasshopper, a classic algorithm was programmed in the Iron Python programming
language (version 2.7.3) [6]. Iron Python is integrated into Grasshopper and directly
builds on its visual algorithms, thus enabling the formation of a continuous process.
2.1. DISCONTINUITY IN GEOMETRY
Kangaroo can generates two lists as output in addittion to the mesh: a list of
points-nodes and a list of lines-springs connecting the points. The number of points and
lines is identical to the number of nodes and springs that formed the original mesh of the
base, which means that for the resulting shells a list of reference points-vertices is
obtained that should be analyzed to define the envelope.
The initial approach to the analysis was to group the points into quadrants with
respect to their x and y coordinates, i.e. creating a list of groups of points where if the x
coordinate of a certain point belongs within certain limits and the y coordinate belongs
within certain limits, then the point belongs to a specific group on the list. In a visual
sense, this represents an orthogonal grid of square fields projected in the horizontal XY
plane, and all points, whose projections in the horizontal plane belong within the
boundaries of one field, form a group. The resulting list of groups was analyzed by
looking at all the points within the group and the algorithm singles out the point that has
the highest Z coordinate and the point that has the lowest Z coordinate. The algorithm
sorts the points defined in this way into two lists, a list of points with the largest Z
coordinate, which is used to generate the upper layer of the shell, and a list of points with
the smallest Z coordinate, which is used to generate the lower layer of the shell.
The set algorithm successfully selects the points, but it is dependent on the initial
definition of the mesh, that is, a large number of nodes and sptings needs to be defined as
input information. Otherwise, if the number of defined nodes-points is not sufficient
during their grouping, groups are created within the frames of which there are no
reference points from each shell, which results in discontinuity of the geometry of the
two-layered shell defined by the points. Different directions and directions of horizontal
forces result in different displacement of vertices creating uneven distribution of
reference points and formation of voids.
When considering certain groups of points, it is possible that no reference point
from the shell that has the largest Z-coordinate in that segment exists, which leads the
algorithm to choose a point that is not the true maximum for that segment, resulting in an
error in the definition of the envelope ( Fig. 2). The error correction is removed when a
high-resolution mesh, i.e. a mesh with a large number of nodes, is specified during the
initial calculations in Kangaroo.
Figure 2 Error in network definition: A) discontinuity in shell geometry; B) the result after the
correction of the input data
Such an approach cannot precisely determine the required number of nodes during
the initial definition of the network, and the required result is obtained by trial and error.
Also, providing a high resolution mesh as input to the Kangaroo algorithm significantly
slows down the solver and negates its greatest advantage, providing a precise
approximation of the shape using a small number of reference points.
2.2. INPUT DATA CORRECTION
In order to overcome the problem with the discontinuity of the geometry from the
initial approach, the input information- the points were considered, since it is necessary to
confirm that a representative sample of reference points is defined for each considered
segment.
When considering this problem, it is important to emphasize that the Kangaroo
solver as a result, generate a mesh and not just as a list of reference points. Grasshopper
defines meshes using a data structure: vertex, mesh point - face, polygon. This structure
is simply a list of points that are grouped into polygons (triangles or quadrilaterals) that
form one continuous surface. Initially the algorithm works only with the vertices of the
network, using them directly as reference points. But a surface (mesh) is also obtained,
not just a list of vertices, which offers the possibility to define an unlimited number of
points belonging to the surface.
A built-in Grasshopper function is used to determine reference points from the
shells: Project Point, which allows any given point to be projected onto a given geometry
in the direction of a given vector. In the specific case, this means that if a series of points
are set in the horizontal plane, they can be projected onto the shells in the direction of the
Z axis (Fig. 3). This approach offers two advantages. Namely, the projected points are
fixed in terms of their x and y coordinates for each of the individual shells, thus obtaining
reference points that have identical x and y coordinates, which allows overcoming the
problem of creating voids, obtaining reference points from all shells which exist for the
given coordinates. In addition, projecting a point on a given surface is a process that the
software works with much faster and easier, compared to the Kangaroo solver, which
leads to a faster result and allows obtaining a much larger list of reference points, that is,
a much more precise definition of the envelope.
Figure 3 Defining new entry points through the projection of points from the XY plane onto the
shells in the direction of the Z - axis
When defining the series of points, it is important to define the boundary in which
the points will be set, in order to obtain reference points, so that the envelope can cover
all the shells with certainty. As the boundary of the reference points for obtaining the
upper layer of the shell we define the part of the XY plane in which at least one of the
shells exists, while as the boundary for the lower layer of the shell we define the part of
the plane in which all the considered shells exist. This is necessary because in certain
segments there is only one of the shells and in such a case it represents a part of the upper
layer of the shell, and since there are no other reference points it would be defended as
both the highest and the lowest point. Boundaries are formed by taking the projections of
each of the shells in the XY plane and defining their union and their intersection. The
points are given as vertices of a grid defined by the union of curves of all projections of
the shells in the horizontal plane. This list of points is supplemented by the points of the
curve which defines the difference of all projections in the horizontal plane.
3. PYTHON COMPONENT FOR SELECTION OF HIGHEST AND LOWEST
POINTS (CLASSICAL ALGORITHM)
The functions of the algorithm described so far are defined through a visual
language, without classical writing of code, because so far the necessary operations can
be done by already existing Grasshopper components. However, the grouping of points
according to their xy coordinates and the selection of the local highest and lowest point
according to the z coordinate are not available as a ready-made component in the virtual
environment and must be scripted as a new native component. Grasshopper supports the
use of several programming languages: Python, C# and VB.Net. For the purposes of this
paper, it has been decided that the code will be written in the Python programming
language.
Figure 4 The visual algorithm built from available components (the new component programmed
through Python is highlighted in red)
In the new Python component, three lists of points are defined as input data, a list
of points obtained by projection of the points within the union of the projections
(union_points); a list of points that belong to the intersection of the projections
(intersection_points) and a list of points that are stationary during the simulation – pinned
supports (anchor_points). Three lists of points are obtained as output data, which define
the upper and lower layers of the shell, i.e. the upper and lower limits of the envelope,
and the stationary points - the supported - are separated again as separate ones.
Figure 5 The component scripted in Python, which performs the selection of the highest and lowest
points
The first step is to purge the list of points that we enter as input data from
Grasshopper. This entails deleting any empty elements that might accidentally be on the
list as result of the process in Grashopper. For this purpose, the function filter is called
which is available from the Python core library, which requires two arguments: a criteria
to list and a list to be checked.
union_temp = filter(None, union_points)
intersection_temp = filter(None, intersection_points)
The first function we define helps us calculate the distance between the
projections of two points on the XY plane using their x and y coordinates. Since the
distance calculation will be used multiple times in the algorithm, it is best to define it as a
function that will be simply called later.
def distance_xy_points(pt1, pt2):
d = math.sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2)
return d
The function defined in this way is used to identify the clusters of points that are
created around the supports (the points that were defined as stationary when calculating
the shell through the Kangaroo solver). Kangaroo cannot define an ideal stationary
bearing/point, therefore, in different load cases, it comes to defining different positions of
the bearing that are at a minimum distance between each other. Although this deviation in
reality is negligible, it can lead to errors in the operation of the algorithm, and therefore it
is best to eliminate these clusters and replace them with the original bearing points, the
ones assigned to Kangaroo. To identify, the function for calculating the distance between
points is used, that is, the points that are very close to the original bearing points are
extracted from the list of points, and they are deleted.
cluster_union = []
for point in union_temp:
for anchor in anchor_points:
if distance_xy_points(point, anchor) < 0.1:
cluster_union.append(point)
list_union = []
for point in union_temp:
if point not in cluster_union:
list_union.append(point)
cluster_intersection = []
for point in intersection_temp:
for anchor in anchor_points:
if distance_xy_points(point, anchor) < 0.1:
cluster_intersection.append(point)
list_intersection = []
for point in intersection_temp:
if point not in cluster_intersection:
list_intersection.append(point)
After deleting the clusters on the list of points, the original points of the supports
(anchor_points) which were taken as input information on a separate list from
Grasshopper are returned.
list_intersection.extend(anchor_points)
list_union.extend(anchor_points)
The next step is to group the points according to their xy coordinates. The same
function is used to calculate the distance between the projections of two points. The new
definition of the input points results in which points have the same, or approximately the
same, x and y coordinates. Namely, the groups of points are now not formed from points
whose coordinates belong to a certain domain, but are grouped together if they have the
same, or approximately the same x and y coordinates, whereby approximately the same
coordinates mean that there is a certain degree of tolerance, in order to take into account
the possible inaccuracy when the algorithm considers rational numbers, due to the
rounding of decimals.
list_of_groups_union = []
list_of_groups_intersection = []
tracker_union =[]
for point_1 in list_union:
if point_1 not in tracker_union:
group_union=[]
for point_2 in list_union:
if distance_xy_points(point_1, point_2) < 0.01:
group_union.append(point_2)
tracker_union.append(point_2)
list_of_groups_union.append(group_union)
tracker_intersection =[]
for point_1 in list_intersection:
if point_1 not in tracker_intersection:
group_intersection=[]
for point_2 in list_intersection:
if distance_xy_points(point_1, point_2) < 0.01:
group_intersection.append(point_2)
tracker_intersection.append(point_2)
list_of_groups_intersection.append(group_intersection)
Points grouped like this are considered in terms of their Z coordinates, their
height. Two points are selected from each of the previously defined groups, one with the
highest Z coordinate, the other with the lowest. The selected points are grouped into two
new lists, a list of points with the highest Z coordinates (high_Points) and a list of points
with the lowest Z coordinates (low_Points).
high_Points = []
low_Points = []
high_point = list_of_groups_union[0][0]
low_point = list_of_groups_intersection[0][0]
for i in range(len(list_of_groups_union)):
max_Z = float('-inf')
for point_x in list_of_groups_union[i]:
current_Z = point_x[2]
current_point = point_x
if current_Z > max_Z:
max_Z = current_Z
high_point = current_point
high_Points.append(high_point)
for i in range(len(list_of_groups_intersection)):
min_Z = float('inf')
for point_x in list_of_groups_intersection[i]:
current_Z = point_x[2]
current_point = point_x
if current_Z < min_Z:
min_Z = current_Z
low_point = current_point
low_Points.append(low_point)
These two lists represent output information from the Python component which
further defines new grids representing the upper and lower bounds of the envelope with
the help of available components from Grasshopper.
Figure 6 Final results of the selection of the points: A) Lower limit; B) Upper limit
4. CONCLUSION
The biggest benefit of implementing dynamic relaxation, as a method of creating
the form, in the early stages of the design can significantly improve the final result of the
form in terms of load-bearing characteristics. Such algorithms are primarily intended for
architects and planners and reduce the time required for the development of the project,
enabling an efficient process through which a variety of possible solutions of the form are
quickly and simply considered, which always take into account the given form of the
base, the defined boundaries conditions and intensity of seismic force. The added value
of the forms obtained in this way, in contrast to the arbitrarily designed ones, represents a
much better basis for further development and constructive analysis, which means fewer
changes in the design process and better control from the beginning.
Defining the envelope is a function that is built into different software packages,
but for the set purposes it is necessary to implement the method in the appropriate
software, so its entry into Rhinoceros3D and Grasshopper makes it available as a tool for
projecting the shape even when defining the very concept for the project, and by applying
the specific software, analyzes from the aspect of aseismic design are possible. In
addition, working in parametric software allows the generated forms to be immediately
considered from other aspects in relation to the program requirements, the environment,
the lighting, so that the optimal form can simply be adopted.
Future research should be aimed at refining the proposed algorithm and further
testing it on different base shapes, geometric irregularities in the base, and defining the
support points in terms of how they affect the shape.
Figure 7 Top and bottom layer of shells obtained using the presented algorithm
REFERENCES
[1] Michiels T. L. (2018). Form finding of arches and shell structures subjected to seismic
loading. PhD thesis. Princeton University, New Haven, USA.
[2] McNeel, R., & others. (2010). Rhinoceros 3D, Version 6.0. Robert McNeel &
Associates, Seattle, WA.
[3] Piker D. (2013). Kangaroo: form finding with computational physics. Architect Des 83(2),
pp.136–137.
[4] Verlet L. (1967). Computer experiments on classical fluids, I. Thermodynamical properties
of Lennard-Jones molecules. American Physical Society vol.159.
[5] Adriaenssens S., Block P., Veenendaal D. and Williams C. (2014). Shell Structures for
Architecture: Form Finding and Optimization. New York, USA.
[6] Harris, A. (2010). Scripting via IronPython. In: Pro ASP.NET 4 CMS. Apress.
https://doi.org/10.1007/978-1-4302-2713-7_7
View publication stats
