Simulation Design Tools

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.

Morphogenetic Studio is an experimental investigation of form generating processes through digital as well as analogue tools. The studio takes its starting point in an exploration of how relations between the general and the specific might be challenged by digital design techniques. Architects have of course always been interested in how general principles could be unfolded in specific design solutions informed by specific contextual conditions, but digital tools offer new ways of investigating these questions through the use of scripting and parametrically controlled models.  Digital models also offer new ways of linking design and realisation processes, which is another core interest of the studio. Morphogenetic Studio investigates these questions with an emphasis on spatial and tectonic potentials and possibilities.

 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

Tutors: Robert Stuart-Smith, Knut Brunier, Niels Martin Larsen, Sebastian Gmelin
Rhino scripting, laser cutting

www.processing.org

1. In Eclipse, right-click on the main project folder and chose >team< … >update< in the context menu. This will upload changes other users made into your local code copy.
   
2. Start Cygwin shell, and direct to your workspace folder
   1. c:

   

   2. cd Users/[…]/workspace/build
3. run the batch build command “./build.sh clean dist”




4. In Eclipse, right/click on the main project folder and chose >refresh< in the context menu.



5. Chose >Project< in the main menu bar and >clean< the project



6. Right-click on the main project folder (or changed folder) and chose >team< … >commit< to commit your changes to the server copy of the code.

Wrote a simple script that simulates chain models in Microstation. A series of chain segments of a specific length is defined. Some knots are fix others can move.

‘Simulation of a chain model
‘Sebastian Gmelin
’15.11.2009

Option Explicit

Const gravity As Double = 1 / 5
Const springforce As Double = 1 / 8
Const attrForce As Double = 3

Public Type sphere
    number As Long
    radius As Double
    center As Point3d
    newCenter As Point3d
    sElements(3) As Element
    numNeighbours As Long
    Neighbours(10) As Long
    connections(10) As Element
    moveable As Boolean
End Type

Dim spheres() As sphere

Function createSphere(pos As Point3d, rad As Double, number As Long, moveable As Boolean) As sphere
   
    Dim elem As Element
    Dim mat As Matrix3d
   
    createSphere.center = pos
    createSphere.newCenter = pos
    createSphere.radius = rad
    createSphere.moveable = moveable
    createSphere.number = number
    createSphere.numNeighbours = 0
   
    Set elem = CreateLineElement2(Nothing, pos, pos)
    elem.Color = 3
    If moveable Then elem.Color = 1
    elem.LineWeight = 8
    elem.LineStyle = ActiveDesignFile.LineStyles(1)
    ActiveModelReference.AddElement elem
    elem.Redraw
    Set createSphere.sElements(0) = elem
   
    mat = Matrix3dFromAxisAndRotationAngle(2, 0)
    Set elem = CreateEllipseElement2(Nothing, pos, rad, rad, mat, msdFillModeNotFilled)
    elem.Color = 6
    elem.LineWeight = 0
    elem.LineStyle = ActiveDesignFile.LineStyles(2)
    ActiveModelReference.AddElement elem
    elem.Redraw
    Set createSphere.sElements(1) = elem
   
    mat = Matrix3dFromAxisAndRotationAngle(1, Pi / 2)
    Set elem = CreateEllipseElement2(Nothing, pos, rad, rad, mat, msdFillModeNotFilled)
    elem.Color = 6
    elem.LineWeight = 0
    elem.LineStyle = ActiveDesignFile.LineStyles(2)
    ActiveModelReference.AddElement elem
    elem.Redraw
    Set createSphere.sElements(2) = elem
   
    mat = Matrix3dFromAxisAndRotationAngle(0, Pi / 2)
    Set elem = CreateEllipseElement2(Nothing, pos, rad, rad, mat, msdFillModeNotFilled)
    elem.Color = 6
    elem.LineWeight = 0
    elem.LineStyle = ActiveDesignFile.LineStyles(2)
    ActiveModelReference.AddElement elem
    elem.Redraw
    Set createSphere.sElements(3) = elem
   
End Function

Sub moveSphere(s As sphere, vec As Point3d)

    Dim i As Long
   
    s.center = Point3dAdd(s.center, vec)
   
    For i = 0 To UBound(s.sElements)
        Call s.sElements(i).Move(vec)
        s.sElements(i).Rewrite
        s.sElements(i).Redraw
        ‘ActiveDesignFile.Views(1).Redraw
    Next i
   
End Sub

Sub moveConnections()

    Dim s As Long
    Dim c As Long
   
    For s = 0 To UBound(spheres)
        For c = 0 To spheres(s).numNeighbours – 1
            Call spheres(s).connections(c).AsLineElement.ModifyVertex(0, spheres(s).center)
            Call spheres(s).connections(c).AsLineElement.ModifyVertex(1, spheres(spheres(s).Neighbours(c)).center)
            spheres(s).connections(c).Rewrite
            spheres(s).connections(c).Redraw
        Next c
    Next s

End Sub

Sub makeSphereFix(s As Long)

    spheres(s).moveable = False
    spheres(s).sElements(0).Color = 3
    spheres(s).sElements(0).Rewrite
    spheres(s).sElements(0).Redraw

End Sub

Sub makeSphereMoveAble(s As Long)

    spheres(s).moveable = True
    spheres(s).sElements(0).Color = 1
    spheres(s).sElements(0).Rewrite
    spheres(s).sElements(0).Redraw

End Sub

Sub drawConnections(s As Long)

    Dim elem As Element
    Dim points(1) As Point3d
    Dim i As Long
   
    For i = 0 To spheres(s).numNeighbours – 1
        points(0) = spheres(s).center
        points(1) = spheres(spheres(s).Neighbours(i)).center
        Set elem = CreateLineElement1(Nothing, points)
        elem.Color = 2
        elem.LineWeight = 2
        elem.LineStyle = ActiveDesignFile.LineStyles(1)
        ActiveModelReference.AddElement elem
        elem.Redraw
        Set spheres(s).connections(i) = elem
    Next i

End Sub

Sub calculateSphereMove(s As Long)

    Dim i As Long
    Dim k As Long
    Dim direction As Point3d
    Dim dist As Double
    Dim length As Double
    Dim grav As Boolean
    Dim vec As Point3d
    Dim tension As Double
   
    If spheres(s).moveable Then
    tension = 0
        For i = 0 To spheres(s).numNeighbours – 1
            direction = Point3dSubtract(spheres(spheres(s).Neighbours(i)).center, spheres(s).newCenter)
            dist = Abs(Point3dMagnitude(direction))
            ‘Debug.Print (“distance ” + CStr(dist))
            length = spheres(s).radius + spheres(spheres(s).Neighbours(i)).radius
            ‘Debug.Print (“length ” + CStr(length))
            tension = tension + dist – length
        Next i
        tension = tension / (spheres(s).numNeighbours)
        grav = True
        If tension > 0 Then
            spheres(s).newCenter = Point3dAdd(spheres(s).newCenter, Point3dFromXYZ(0, 0, -0.1 * gravity))
        Else
            spheres(s).newCenter = Point3dAdd(spheres(s).newCenter, Point3dFromXYZ(0, 0, -1 * gravity))
        End If
        vec = Point3dFromXYZ(0, 0, 0)
        For i = 0 To spheres(s).numNeighbours – 1
            direction = Point3dSubtract(spheres(spheres(s).Neighbours(i)).center, spheres(s).newCenter)
            dist = Abs(Point3dMagnitude(direction))
            ‘Debug.Print (“distance ” + CStr(dist))
            length = spheres(s).radius + spheres(spheres(s).Neighbours(i)).radius
            ‘Debug.Print (“length ” + CStr(length))
            If (dist – length) > 0 Then
                grav = False
                direction = Point3dScale(direction, attrForce * springforce * (dist – length) / (dist))
            Else
                direction = Point3dScale(direction, springforce * (dist – length) / (dist))
            End If
            vec = Point3dAdd(vec, direction)
        Next i
        spheres(s).newCenter = Point3dAdd(spheres(s).newCenter, vec)
    End If

End Sub

Sub moveSpheres()

    Dim i As Long
    Dim s As Long
    Dim vec As Point3d
   
    For s = 0 To UBound(spheres)
        vec = Point3dSubtract(spheres(s).newCenter, spheres(s).center)
        spheres(s).center = spheres(s).newCenter
   
        For i = 0 To UBound(spheres(s).sElements)
            Call spheres(s).sElements(i).Move(vec)
            spheres(s).sElements(i).Rewrite
            spheres(s).sElements(i).Redraw
            ‘ActiveDesignFile.Views(1).Redraw
        Next i
    Next s
End Sub

Sub Main()

    Dim i As Long
    Dim k As Long
    Dim s As Long
   
    Randomize

    ReDim spheres(99)
    For i = 0 To 9
        For k = 0 To 9
            spheres(i * 10 + k) = createSphere(Point3dFromXYZ(i, k, 0), 0.65, i * 10 + k, True)
        Next k
    Next i
   
    For i = 0 To 9
        For k = 0 To 9
            ‘spheres(i * 10 + k) = createSphere(Point3dFromXYZ(i, k, 0), rnd * 0.2 + 0.5, i * 10 + k, True)
            If i < 9 Then
                spheres(i * 10 + k).Neighbours(spheres(i * 10 + k).numNeighbours) = i * 10 + k + 10
                spheres(i * 10 + k).numNeighbours = spheres(i * 10 + k).numNeighbours + 1
            End If
            If k < 9 Then
                spheres(i * 10 + k).Neighbours(spheres(i * 10 + k).numNeighbours) = i * 10 + k + 1
                spheres(i * 10 + k).numNeighbours = spheres(i * 10 + k).numNeighbours + 1
            End If
            If i > 0 Then
                spheres(i * 10 + k).Neighbours(spheres(i * 10 + k).numNeighbours) = i * 10 + k – 10
                spheres(i * 10 + k).numNeighbours = spheres(i * 10 + k).numNeighbours + 1
            End If
            If k > 0 Then
                spheres(i * 10 + k).Neighbours(spheres(i * 10 + k).numNeighbours) = i * 10 + k – 1
                spheres(i * 10 + k).numNeighbours = spheres(i * 10 + k).numNeighbours + 1
            End If
            Call drawConnections(i * 10 + k)
        Next k
    Next i
   
    ‘Call makeSphereFix(0)
    Call makeSphereFix(9)
    ‘Call makeSphereFix(55)
    Call makeSphereFix(90)
    Call makeSphereFix(99)
   
    For i = 0 To 75
‘        Call moveSphere(spheres(Round(Rnd * 99)), Point3dFromXYZ(0, 0, Rnd * 0.5 – 0.25))
‘        Call moveConnections
        For s = 0 To UBound(spheres)
            Call calculateSphereMove(s)
        Next s
        Call moveSpheres
        Call moveConnections
        ActiveDesignFile.Views(1).Redraw
    Next i
   
End Sub

Hyperbolic paraboloids (HP) are discribed by the formula

The below script creates HPs in Microstation within a certain range of  x and y coordinates. The dashed lines indicate the regular grid on coordinate system. These are of parabolic shape. The thick diagonal lines are all straight. They are the reason why this shape is interesting for construction, as it can be discribed as a series of straight lines. Intersecting the surface with a horizontal plane creates hyperbolas (blue curves).

Hyperbolic paraboloid

I started reading on Curve models and geometries, different types of Spline algorithms. This is a first attempt to generate Bezier curvers using the algorithm of de Casteljau. The script uses a selected polyline as the control polygon of the curve. The Bezier is created in several steps to illustrate the process. It runs under Microstation MVBA.

Bezier curve of degree 3

Bezier curve of degree 4

Bezier curve of degree 5

Bezier curve of degree 8

more Bezier curves

more Bezier curves

more Bezier curves

more Bezier curves

more Bezier curves

Having seen a rebuilt of Itten’s “Tower of Fire” at the Bauhaus exhibition, I started swcripting a parametric model of the tower in the spirit of the workshop we’re planning to do next year. The VBA script runs in Microstation and is modified by the following parameters:

• cSize As Double = edgeLength of the bottom cube
• cAngle As Double = rotation in plan between each cube
• cNumber As Long = number of cubes / levels
• cScale As Double = the bottom radii of the cones equals the diagnal conrner distance by default. This is scaled by cScale parameter
• uSeg As Long = Number of linear panels on cone
• vSeg As Long = Number of circular panels on cone
• cRad As Double = Radius of panel frames

Images of rebuilts of the tower:

• on focus.de
• on n24.de

tower of fire 01

tower of fire 01 top view

tower of fire 02

tower of fire 02 top view

tower of fire 03

tower of fire 03 top view