This “Simulation Design Tool” is inspired by Gaudi’s work. It turns neshes into so called Particle Spring Systems that act similar to physical hanging chain models.
The resulting “funicular shapes” represent structures performing well as tension systems – or, when inverted – as pressure structures.

The most simple system is a single haning chain as shown in the following video. The segmented line sinks and approximates a catenary shape.

To start a simulation, a B-net is drawn. Using the subdivision tools in the context menu the shape is subdivided to create panels.

Attaching a PhysicsSpringSystem to this B-net, turns it into a Particle Spring System. The vertices of the Net become particles and the edges connecting them turn into elastic springs. When starting the simulation, the system relaxes and starts moving. Changing the gravity moves the particles up or down.

Using the sliders on the right, additional constraints can be applied to the system. They act as additional forces on each panel, trying to planarize it or qualizing its edges’ or diagonals’ length. The system autommatically balances all applied forces.

When re-editing the underlying B-net, the simulation adopts. Changes in edges’ length are translated into changes of spring restlengths. Fixpoints will move along automatically.

Attaching a PhysicsMeshExtrusion to the simulation B-net creates a thickened shell. The thickness of the shell is informed by the spring forces in the system. The higher the imbedded forces, the thicker the shell. This is a relative assignment and the minimum and maximum thickness are controled by sliders.

The shape can be modified locally by using one of the specialist tools. They allow control over local spring forces (relaxing or tightening) and over local vertex weight.

Using Parametric Building Information Modeling and Physical Simulation for Form Finding of Double Curved Surfaces.

Sebastian Gmelin1, Kristian Agger2, Michael Henry Lassen3

1,2Aarhus School of Architecture, Denmark, 3Alexandra Institute, Denmark

1,2,3http://www.B-processor.dk, 1,2http://www.aarch.dk, 1http://www.gmelin.li, 3http://www.alexandra.dk

1sebastian@gmelin.li, sebastian.gmelin@aarch.dk, 2kristian.agger@aarch.dk, 3henryml@cs.au.dk

Abstract. Parametric modeling is a powerful tool to create variations of a design following specified criteria. Physical modeling provides flexible relationships between design elements and can simulate the behavior of hanging chain models. Building Information Modeling can contain geometry and design properties and relations. In this paper it is proposed to join all three to create a Simulation Design Tool that allows the intuitive creation of double curved surfaces which follow the rules of funicular systems (Figure 1). This tool is implemented in B-processor, open-source Building Information Modeling software to bridge the break that occurs when moving from a design software package to Building Information Modeling. It is shown how the tool balances intuitive sculpting and accurate simulation and how the user can interact to mediate different design requirements.

Keywords. Form Finding; Parametric Building Information Modeling; B-processor; Particle Spring System; Grid Shell.

Figure 1
Shell Structure created in B-processor using Physical Simulation Design Tools

Introduction

Ambitious architectural design often relies on computational technologies these days. Parametric design and freeform surface modeling tools allow the creation of complex geometries that challenge construction methods. The logistics of these kinds of projects can become very sophisticated. The work effort and the process of translating geometry into shop drawings, producing construction elements and assembling them on site is multiplied by the number of different pieces and the variation of elements. Complexity becomes so high that consultants and construction companies specialize in these projects and support architects and engineers.

To handle such projects, drawings and specifications are complemented with parts schedules, CNC production code, parts labeling, position tags and special assembly strategies. To manage the variety of elements or minimize the variation in an optimization phase, these documents are usually created from parametric 3D models, which are highly specialized Building Information Models.

This is interesting because BIM technologies and software are usually not considered to be design tools. More general tools, often not even particular (architectural) CAD software is used to generate shape. The desire for freedom and flexibility is driving the design phase, while full control and precision of this design is the ultimate wish before going on site. These two extremes seem to split the traditional gradual workflow in architecture, starting from a first sketch until the creation of construction and shop drawings. The advantage of a smooth workflow is obvious, when (for any reason) the design or parts of it need to change. If the design model is not linked to the information model properly, this change might be laborious work.

The second aspect of this split is the question of constructability and economy of design. Both can only be answered with enough information at hand, meaning when a BIM model is developed. Minimizing the variation of elements, simplifying and optimizing the shape towards a specific construction method might only be done with the help of a parametric model that contains enough information about this construction. Of course these phases can be linked and a parametric setup can use a design surface as an input parameter, but these solutions are currently special answers to unique problems. It is also difficult to link the design back to the outcomes of an optimization result.

It is suggested to try using a Building Information Modeling environment for the design of complex geometries; bundling design, optimization and information phases to grow and refine shapes with the addition of detail and construction. The requirement of such software is the combination of flexibility and accuracy. While a design develops, information is added continuously, both manually and automatically; aspects of a design inform each other.

Simulation Design Tools

‘The concept of Building Information Modeling is to build a building virtually, prior to building it physically, in order to work out problems , and simulate and analyze potential impacts’ (Olcay 2010) . Pursuing the idea above, these results should not only be used to check but also re-inform the design. Instead of defining an iterative process of designing, analyzing, re-designing and re-analyzing, it is proposed to create a combination of design and analysis: simulation design tools. Simulation design uses the object property tags, meaning Building Information, to re-inform design tools. The designer works intuitively and creates desired shapes while a simulation or analysis is run in parallel processing these parameters. The tool balances user input against simulation results. Many different simulations can be considered for such tools: structural performance, thermal analysis or self shading studies, acoustical performance of spaces, or spatial relationships of rooms. It could also be imagined to use security simulations, crowd control or building sensor positioning as a simulation driver and of course combinations of these.

To achieve this, any simulation algorithm needs to be simple enough to run at high speed not to compromise the intuitive feel to the user. At the same time it has to be precise enough to create exploitable information. This choice between intuition and precision has to be answered for each individual tool. Most likely such simulation design tool will not meet the expectations of relevant specialized analysis software.

Common surface modeling tools translate user input directly into change of geometry. Moving its control points affects a B-Spline surface directly. This would contradict the idea of simulation design. Instead of changing geometry, the designer changes parameters of the simulation. This does not necessarily mean that only number values can be changed to modify a shape. To develop tools giving the impression of sculpting a shape while actually changing simulation properties is important to make the idea successful. Examples of how this could be implemented for a specific case will be shown later in this paper.

The result of this process is not only geometrical shape but also attached information. Both are directly created from the simulation and therefore updated when the shape is changed again. It is an important aspect of this process that information is not added separately in an additional step. In contrary: geometry and information form a unity and are created together. They are not just linked; they interact and ideally contain objective parameters which can help to proceed the design development.

This should not be mistaken for building components that can be placed in many BIM software packages. Those components are ready-made parametric building parts also containing geometry and relevant information. They can be modified to adopt different situations. Simulation design however does not aim to create a complete building or building-part in one step. It just tries to solve one design criterion with its related analytical aspect. The outcome might be a construction component but could as well be much more abstract: a form that maximizes views and minimizes shade, a shape that creates good acoustics or performs well structurally. Information stored in such a model is therefore not only describing the final design but also criteria that were chosen to make a design decision.

B-processor – Building Information Modeling

B-processor [3] forms the framework for the project. It is open-source BIM software currently being developed at the Aarhus School of Architecture in collaboration with the Alexandra Institute (Agger, Lassen, Knudsen, Borup, Rimestad, Norholdt, Bramsen, 2007). This lightweight CAD environment allows simple modeling in the style of Google’s Sketch-up.

B-processor translates Building Information Modeling very literally. It allows the creation of geometric 3d models and to attach information properties to its building objects. These are related and can refer to each other. In B-processor, building objects are organized in spaces. Those can be functional or constructional and have references to geometrical elements describing the shape of the space. Spaces hold properties: values, descriptions and classifications. Relations between spaces are solved automatically when spaces share a surface. To describe abstract parts of a design, like grids, guidelines, etc, an additional element was introduced: a B-Net. It is also a space that contains faces, lines and vertices but it is not taken into account when calculating relationships or schedules. This simplistic approach and the flexible architecture of B-processor allow design modeling as well as information modeling. (Figure 2).

The essential aspect of B-processor is its open-source license. This is a possible answer to the problem of compatibility of different software packages and file formats. The more information a Building Model contains, the more difficult it becomes to exchange its data. The idea is to allow users to modify the software to their needs. Data created in B-processor will never be lost, because the software is free and everybody involved in a project can use it without purchasing expensive licenses.

Figure 2
Model of the Ruin Hall in Kolding, created in B-processor

In a first phase of this research project, parametric objects were integrated in B-processor. They form the base for any simulation design tool as envisaged. Desired strategies depend on flexibility of geometry, constraints and dependencies. The kernel of the software was changed to allow any object drawn to become parametric by attaching scripts to it. Their parameters can be numerical or graphical, like grids or points. The information tags of an object can be used as parametric properties. There is no difference between information that is added manually or automatically by a tool and both can be used to inform the design through simulation tools.

Example – Physical Simulation Tool

As a first example and to challenge the above ideas, physical simulation was implemented in B-processor. As shown by Axel Kilian and John Ochsendorf (2005), particle-spring systems can be used to simulate hanging chain models. The shape of hanging chains represents so called funicular forms of tension and can be inverted to create pure compression structures. Many designers experimented with this technique: Gaudi, Heinz Isler and Frei Otto for example. Rebuilding Gaudi’s hanging model of Colonia Güell (Figure 3), Frei Otto (1989) and his team showed how laborious the creation of such a physical model is. The complexity of this process and of the resulting shapes makes it a valid case for a computational approach. Following Axel Kilian’s research, a tool is developed that uses a particle-spring system based on a Verlet algorithm, solving Newton’s laws of motion for a number of particles reacting to forces and moving in space.

Figure 3
Hanging Model of Colonia Güell, Gaudi, source: http://www.rolfdieternill.de/pictures/tragwerkslehre082_Page_3.jpg

Different forces act on each particle: gravity, forces of connected springs, damping forces and potentially more. These forces accelerate the particle taking its mass into account and following the equation (1). The movement of particles is calculated for a time step using equations (2) and (3). The Verlet algorithm combines these laws into one equation (4) [1].

Acceleration = Force / Mass (1)

ΔVelocity = ΔTime ∙ Acceleration (2)

ΔDistance = Velocity ∙ ΔTime (3)

ΔDistance = Velocity ∙ ΔTime + 0.5 ∙ Acceleration ∙ ΔTime2 (4)

To create such a system, the user draws any B-Net in B-processor. A “physics system” is then attached to the geometry. It automatically generates particles from all vertices and springs from all edges. Global parameters define the behavior of the simulation. To simplify the workflow, they are applied to all elements. The user can choose to change these settings locally, though, if desired. These parameters are gravity, mass, spring constant and spring equilibrium length and are used to calculate the forces acting on particles (5) (6).

Gravity Force = Mass ∙ Gravity (5)

Spring Force = -Spring Constant ∙ (Spring Length – Equilibrium Length) (6)

When starting the simulation, the particles begin to move and to deform a copy of the original B-Net. If gravity is defined other than 0, the particles are accelerated along the negative Z-axis resulting in a tension form. This can be easily reverted by applying a positive gravity that pulls the particles upwards. To prevent the whole system from moving, single vertices can be defined as fix points. The movement of particles stretches the springs until their force is strong enough to bring the system to equilibrium. The user has several possibilities to interact while the simulation is running in order to control and modify form:

1. 1. Modifying the original, underlying b-Net: A change in the original geometry modifies the properties of the physics system accordingly. Increasing or decreasing the length of an edge results in a corresponding change of the relevant springs’ equilibrium lengths
2. 2. Moving fix points: The positions of fix points are constantly tracked and updated. When a fix point is moved, the according point of the physics system is dragged to follow it.
3. 3. Changing global parameters: a change of gravity, mass or global spring constant is an easy way to control the dilation of the system and the resulting curvature.
4. 4. Changing parameters locally: Selecting an edge of the design shape allows the user to change the spring parameters for this single edge. Increasing or decreasing its spring constant or equilibrium length gives control over its stretching behavior making it stiffer or more flexible. Selecting a vertex allows the changing of its related particle’s mass.

Figure 4
Creation and Modification of a Funicular Shape

To enhance the intuitive feel, sculpting tools were implemented that allow modifying the shape locally through mouse input. Choosing such a tool, the mouse pointer becomes a “brush” that defines an area affecting the change. The user selects and clicks on parts of the geometry to change them. Selecting only a vertex, results in a very local change while selecting faces affects a wider area of the form. The tool translates the user’s input into modification of parameters. It can therefore not result in an immediate change of geometry. In fact, the user outweighs the equilibrium and the particles will move again until reaching a new state of balanced forces. Two different sculpting tools were created to illustrate this.

1. 1. Changing the equilibrium length: With this tool, mouse input actually results in a change of the length a spring tries to reach. The user can relax or tension the shape locally, having the impression of pulling or pushing a surface. Translating this back to a physical hanging chain model, where the springs are actually chains or ropes and particles are represented by weights hung to them, this would mean a change to the length of rope between to weights. In the simulation, this connection is not subdivided and stays straight. It could be considered as a system of adequately stiff sticks that are flexibly connected to each other.
2. 2. Modifying particle masses: Similarly to the above tool, the user changes the shape locally. Instead of modifying the springs, the tool changes the mass of particles. While increasing or decreasing that property, the impression of pulling or pushing the surface is generated. Looking at the physical hanging chain model, this can be regarded as changing the weights hung to the chains without changing their geometrical relations.

The flexible interaction of the user causes a diversion from an optimal structural solution. The advantage of using a simulation tool to mediate different requirements is that user input and computational analysis are in constant dialogue. The shape adapts automatically to parameter modification and local changes are built into the system as a whole. Because it is a flexible shape that can constantly change, more requirements can easily be assigned to it as long as they can be expressed by forces acting on particles. Additional demands might be the optimization of faces regarding similarity, planarity or rectangularity. Inspired by the work of Daniel Piker who developed the physics plug-in “kangaroo” for Rhino with Grasshopper [2], these design parameters were implemented in the tool. They all use the faces of the underlying B-Net to assign relevant forces to the particles linked to those faces’ vertices. The following forces can be assigned to the system:

1. 1. Equal face edges: Additional springs are assigned to the face’s edges. Their equilibrium length is defined as the average edge length. They act in parallel to existing springs, enforcing or contradicting them. Triangles try to become equilateral and quadrilateral shapes try to become rhomboids.
2. 2. Equal face diagonal: This is similar to the equal edges. Springs are assigned to the diagonally opposite particles of quadrilateral shapes. These two springs try to achieve the same average equilibrium length, transforming irregular quads towards trapezoidal shapes.
3. 3. Face rectangularity: This is actually not a single parameter but rather a combination of 1. and 2. A quadrilateral shape with even edge length and both diagonals being the same length is a square. As the forces are keeping the system flexible the resulting shapes become more rectangular.
4. 4. Face planarity: For each face of more than three vertices, an average plane is calculated from all vertices. A force is applied to each particle of the face dragging it perpendicularly towards this average plane.

It is most unlikely that all these demands, when applied, are being fulfilled perfectly. Depending on the form, the requirements of similar, regular and planar shapes can only be reached to certain extent while compromising the original hanging form. By changing the strength of relevant forces, the user chooses how to weight different parameters. Assessing a parameter as very strong, compromises other forces and their related requirements. It is left to the designer to mediate all demands.

Figure 5
Applying Additional Requirements as Forces to the Form

The tool does not only create a geometric shape but also stores all information used to come to it as property tags linked to the single entities of the form. Vertices remember their mass, for example, and edges maintain all information on their related spring: length, equilibrium and spring constant.

This combination of geometry and information can drive the next design step. The 3D model becomes an interlinked parametric Building Information Model.

Parametric Building Information Modeling

Before turning any form created with the above method into detailed construction, a volumetric construction space has to be generated from the design surface. A second tool uses geometry and forces created in the first step to automate this process. It thickens the surface unevenly and in relation to the spring forces acting in the edges. This should not be confused with a structural analysis arriving at specific sections for structural members. It is a relative assessment, assuming only that springs that are stretched more from their equilibrium than others are strained more. For the maximum and the minimum spring force, a thickness is assigned and interpolated linearly:

1. 1. The maximum and the minimum spring force are searched by checking all edges of the system.
2. 2. All spring forces are interpolated linearly to values from 0 (minimum force) to 1 (maximum force)
3. 3. For each vertex the average spring force of all connected edges is calculated.
4. 4. From the surrounding surfaces, the average normal is calculated for each vertex.
5. 5. The vertices are moved in direction of their normal and opposite. The translation distance for each direction is calculated using equation (7).
6. 6. The offset vertices are reconnected to create faces enclosing the construction space volume.

Offset = 0.5 ∙ (min. Offset + Force Interpolation ∙ (max. Offset – min. Offset)) (7)

Figure 6
Extrusion of the Hanging Shape in Relation to the Inherited Forces of the Springs

Two options of the offset are created: a shell and a grid-shell version. Because of the non-parallel offset, the faces are not necessarily planar. This can be solved by re-using the physical simulation tool. Setting gravity to 0 and defining the springs’ equilibrium as the actual length of the edges, planarity can be assigned as a single requirement.

Conclusions

The research on simulation design tools is still in its beginning. Combining the ability of Building Information Modeling to link geometric 3D data to any additional information with the flexibility of parametric modeling and the analytical objectivity of simulation might be a powerful strategy for building design. It will be interesting and necessary to develop and test other simulations for such tools. Ideally those tools are:

1. 1. Intuitive – they must work as design tools and allow the user to mediate parameters.
2. 2. Simple – no extensive specialist knowledge should be needed to use the tool.
3. 3. Precise – Simulation results need to be so accurate that they improve the design by objective measure.
4. 4. Neat – any created data must be organized and linked.

Looking at Building Information Modeling as a concept of ‘management of information and the complex relationships between (…) resources’ (Jernigan 2007) rather than restricting software solutions, allows its use for design tasks in a very sophisticated manner and helps to integrate, use and maintain design-relevant data.

For the demonstrated physics simulation and the resulting shapes a proof of the structural performance has to be carried out. This is also an opportunity to develop a link to structural analysis software and to research how simulation design tools and analysis software could communicate and how this could be integrated into the workflow. This study should be completed by adding the possibility to create a more detailed 3D model of a specific construction method, a concrete shell or a grid-shell construction.

References

Agger, K, Lassen, M, Knudsen, N, Borup, R, Rimestad, J, Norholdt, P and Bramsen, N 2007, ‘B-processor -building information design and management’, Predicting the Future, Proceed­ings of the 25th eCAADe Conference, pp. 43–50.

Jernigan, FE 2007, BIG BIM little bim, the practical approach to building information modeling, 4Site Press, Salisbury, Maryland.

Kilian, A, Ochsendorf, J 2005, ‘Particle-spring systems for structural form finding’, Journal for the international Association for shell and spatial structures, IASS, vol. 46.

Olcay, Ç 2010, ‘A review of Building Information Modelling Tools from an Architectural Design Perspective’, in J. Underwood and U. Isikdag (eds), Handbook of research on Building Information Modeling and Construction Informatics, Hershey, New York.

Otto, F (ed.) 1989, The Model, Information of the Institute of Lightweight Structures (IL) No. 34, Karl Krämer Verlag, Stuttgart.

[1] http://www.lonesock.net/article/verlet.html.

[2] http://spacesymmetrystructure.wordpress.com/2010/01/21/kangaroo/.

[3] http://www.B-processor.dk.

http://smartgeometry.org/index.php?option=com_community&view=groups&groupid=2&task=viewgroup

http://archinect.com/features/article/2112195/smartgeometry-2011-copenhagen-denmark

Using given parameters, project “palmtree” tries to create a flexible model that adapts to user input using physical bending parameters of flexible plastic rods of 6 mm diameter.

The “dancefloor”, a 2×3 m timber construction reads in user movement through a series of pressure sensors. They are connected to an Ardurino board and linked to a grasshopper model using firefly. So is a camera, tracking position and rotation of reacTVision markers.
The “dancefloor” represents the buildings plan. Positioning a marker “grows” a tree at the relative position in the room. Moving around and activating the pressure sensors, applies forces to the top of the tree making it bend towards the user’s position.
The trees themselves are woven from elastic plastic rods. Their bending stiffness is approximated using Kangaroo physics plugin. The structure tries to become as straight as possible while the external forces of the user input deform it. The ends of the rods move freely and are attracted to the room’s ceiling using spring forces. When a tree bends, these loose ends “crawl” along the ceiling to find a new connection position.
The project balances real physical input (firefly), physical simulation (Kangaroo) and a physical model: One instance in time was “frozen” and built as a 1:1 structure in the workshop space. While this final structure can’t move or react to user interaction, physical modeling allows a flexible and intuitive formfinding process.

together with:
Asbjorn Sondergard
Pablo Resende
Mario Guidoux

 The studio is based on an integration of architectural teaching and research in the field of digital tectonics and algorithmic design.  The goal is to create an environment that is rooted in specific research subjects and which can generate products that reflect the research and at the same time can become a part of it.

Final installations

Exhibition and Presentation

 Final books and videos 

Morphogenesis Of Ant Swarm Intelligence from Tobias Theil Konishi on Vimeo.

Students:

• Lars Borgen,
• Annica Carina Tomasdotter Ekdahl,
• Kristoffer Rauff,
• Anne Winther Worm,
• Troels Holm,
• Thomas Bang Madsen,
• Mathias Meldgaard,
• Bjarke Lehmann Schødt
• Nikolaj Bogensee Johansen,
• Ragnar Zachariasen,
• Tatiana Mukhina
• Tobias Theil Konishi,
• Mikkel Horsbøl Lauridsen,
• Christine Hauge Ringsmose,
• Agnija Rubene
• Anita Vårbo Berglund,
• Pelle Hviid Andersen,
• Mateusz Bartczak

Teachers: 

• Claus Peder Pedersen,
• Niels Martin Larsen,
• Sebastian Gmelin

Serpentine Pavillon, Jean Nouvel

Parametric Architecture London

Book

Teachers 

1. Claus Peder Pedersen
2. Niels Martin Larsen
3. Sebastian Gmelin

 Students 

1. Lars Borgen
2. Kristoffer Rauff
3. Stefanie Krusch
4. Liv Framgard
5. David Gaarde Mikkelsen
6. Karen Heggheim
7. Nikolaj Bogensee Johansen
8. Ragnar Zachariasen
9. Pelle Hviid Andersen
10. Christine Hauge Ringsmose
11. Kirstine Kannegaard
12. Mikkel Horsbøl Lauridsen
13. Tobias Theil Konishi
14. Sophie Rye Hansen
15. Lasse Lykke Olsen
16. Kristian Kjærgaard
17. Troels Holm
18. Bjarke Schødt
19. Mathias Meldgaard
20. Thomas Bang
21. Anita Berglund
22. Mateusz Bartczak
23. Betina Haraldsen
24. Colm O ‘Brien
25. Tatiana Mukhina
26. Lea Vakili
27. Anne Winther Worm
28. Annica Ekdahl
29. Mika Katarina Friis
30. Jakob Tauman
31. Thomas Lillevang

• Any curved object will need a series of input parameters usually called control vertices, control polygon or control mesh
• This input is used to compute the curve from an algorithm
• There is a desire to change the parameters after the curve was computed. This means the object should provide the flexibility to redraw itself once an input parameter changed.

It was discussed that this problem could be described more generally as a parametric object providing the following functionality and parameters:

• The object is a group of elements: geometrical input, additional parameters, a script (i.e. the algorithm computing a curve) and the resulting geometry
• The script would be run each time of the input parameters (geometrical or additional) is changed.
• Rerunning the script recomputes the resulting geometry. In the case of B-processor this means to delete the previous result and redraw the geometry. It was discussed to only redraw local changes instead of the complete geometry but this will rather be a later optimization.
• All element parts are organized within the object browser as children of the main geometry object, allowing the user easy access.
• The geometry parameters of the object will be realized using the existing B-net functionality.
• The attached scripts should be Java scripts to allow full functionality and access to all methods and properties. In a second step a scripting languages “B-script” could be implemented, allowing the creation of simple scripts.
• The object should be set up very flexibly, i.e. an object should be allowed to create new objects or being the input for other objects (lofts, sweeps…)