Performance Software Approaches for Kinetic Architecture: Programmable Matter Based Simulations

Thesis Director: Alberto T. Estévez, Ph.D.

Ph.D. candidate: Nelson Montás Laracuente, M. Arch.

This thesis project, called “Performance Software Approaches for Kinetic Architecture”, explores how to build digital simulation models to aid in the decision making process in kinetic architectural design. Our ultimate goal is to build a standard way of simulating Shape Memory Materials (SMM) which can be used as actuators in the construction of kinetic structures.

As we moved on to the final stages of the thesis investigation and began to enter the development phase of it, the GH definitions started to give some results, nonetheless they were still not working the way they should have, as we were still decoding (which is still not definitetly finished) the factors that model SMM behavior, currently we have moved on to writing a script to model SMM behavior combining object oriented and visual programming paradigms exploiting Grasshopper’s ability to embed python code in it’s visual code. In these lines, however, we will show only visual code built models as were presented in the thesis’ defense on january 27th, 2016.



Design-fabrication-simulation workflow based on: Raviv, Dan et al. , Active Printed Materials for Complex Self-Evolving Deformations, Scientific Reports, Nature, P. 2

blog entry_Page_2blog entry_Page_1 blog entry_Page_3 blog entry_Page_4
Frame_00000Frame_00022Frame_00006 Frame_00050After a brief, sort of abstract, “testing” experimental exercise, the research tackled some of programmable matter’s fundamental exercises attempting to replicate them through a different method. Our approach was to oultine vector-matrices which, in turn drove algorithms that expressed, in coded fashion, the parametric models by which to approximately replicate already existing, physically modeled, Programmable Matter experimental research done by Raviv et al. and Lendlein and Kelch. 


Theoretical algorithmic data-flow diagram, case study simulation 1, Nelson Montás (2014). Edges: 14, Nodes: 17 , Paths: 14, Inputs: 7; Outputs: 16. Thus applying McCabe’s formula we get CC(G) = e+i+u-n = 14 + 7 + 16 + 7 – 17 = 27.

Since Daniel Davis has established that, up until his thesis (2013), the average Cyclomatic Complexity within the community’s uploaded models database was that of (10), we acknowledge that this diagram, which had resulted in a Cyclomatic Complexity of twenty seven (27), even though abstract, is almost three times higher than what was dubbed “medium sized” CC by Davis. Therefore this simple operation suggested that we almost certainly would have needed to simplify it or rebuild its logical relationships from scratch. One possibility was to embed the first column into the second one as parameters instead of nodes themselves because it was the one column that added the more edges, nodes, paths, inputs and outputs, therefore increasing its final CC result.

NOTE: Thomas McCabe formalized cyclomatic complexity’s most typical formula: CC(G)=e-n+2p
G: the graph. 
e: number of edges. I count parallel edges between identical nodes (duplicate edges) as a single edge. 
n: number of nodes. I do not count non-functional nodes such as comments in text boxes. 
p: number of independent graphs (parts)…
…McCabe’s formula assumes the DAG has only one input node and one output node, which is infrequently the case with parametric models. In an appraisal of common modifications to McCabe’s original formula, Henderson-Seller and Tegarden (1994, 263) show that “additional (fictitious) edges” can be introduced to deal with multiple inputs and outputs. Thus the cyclomatic complexity formula becomes: 
Which (assuming p to be 1) simplifies to:
*Davis, Daniel, Modelled on Software Engineering: Flexible Parametric Models in the Practice of Architecture, School of Architecture and Design College of Design and Social context, RMIT University (2013) P. 78


To illustrate more or less the experiments phase of the research, we have chosen to show three of the 7 case studies, divided in kinematic and kinetic based simulations, which in themselves describe best the aims of the investigation: These were the case studies 3, 6 and 7.

Case study 3 (kinematic) line to spring:

Mostrando image.pngImágenes integradas 2

(Left) Case study 3 simulation, Nelson Montás (2014). This particular case study investigated the use of visual programming to implement “kinematic” models to simulate SMM systems. I this case, a geometry based definition opposed a vector based one used in “kinetic” based models. This specific (Left) case modeled the behavior of a SMA strand that goes from a ‘straight line” form towards a “spring” one. No forces were used in the construction of this model. Actual geometrically constructed straight strand to spring (Right), lendlein and Kelch (2002) (Lendlein, Andreas, Kelch, Steffen, “Shape-Memory Effect: From temporary shape. . . T > 46 C . . .to permanent shape”, Angewandte Chemie, WILEY-VCH Verlag GmbH, 69451 Weinheim, Germany, P. 2037)

Case study 6 (kinetic) Deformation of a 2D grid into a sinusoidal wave:

Mostrando image.png

Case study 6, comparison of both (original and replicated) simulations of the deformation of a 2D grid into a sinusoidal wave, still-frames sequence (perspective view) Nelson Montás (Bottom, 2015) based on Raviv et al. (Top, 2014). Here, the double curvature deformation compared to that of the Raviv et al. simulations and physical models is an astonishingly close approximation to the real models in the original experiments.

Case study 7 (kinetic) deformation of a 2D grid into a double curvature surface (convex and concave):

Mostrando image.pngCase study 7, deformation of a grid into a double curvature surface (convex and concave) Dan Raviv, Wei Zhao, Carrie McKnelly, Athina Papadopoulou, Achuta Kadambi, Boxin Shi, Shai Hirsch, Daniel Dikovsky, Michael Zyracki, Carlos Olguin, Ramesh Raskar & Skylar Tibbits (2014) ( Raviv, Dan et al. , Active Printed Materials for Complex Self-Evolving Deformations, Scientific Reports, Nature, P. 7)

Mostrando image.png

Case study 7, comparison of both (original-Top- and replicated-Bottom) simulations of the deformation of a 2D grid into a double curvature surface (convex and concave) still-frames sequence (left side one-point perspective) Nelson Montás (2015) based on Raviv et al. (2014). The graphic animations show a strong resemblance of the replication simulation with the original one, suggesting that it is probable that force vector analysis is a viable method to simulating programmable matter kinetic systems.


1. Parametric modeling and CAD technology although coming from different disciplines appear to have converged, at least academically, first at Harvard University.

2. It is of most importance to choose the appropriate programming paradigm to build a given simulation in the best way possible, but at the end, it is up to the designer to make that choice.

3. Architects seem to only have between procedural, OOP and data-flow to build parametric models.

4. Visual programming does effectively bypass the edit-compile-run loop but at a price, the computer’s RAM memory availability is diminished making models slower and obliged to be smaller in size.

5. Using modules proved to be of much aid, as suggested by Davis in that they made the
phenomenon that were to be understood be broken down to fundamental “parts”.
6. Cyclomatic complexity proved to be also an effective correction tool to bring down code size.

7. Answering Davis’s questions regarding experimenting with parametric models:
Functionality: Are all the modelling tasks able to be performed by every programming method?N/A
Correctness: Do programs do what is expected? Yes
Ease of use: Are the modelling interfaces easy to use? Not established as a sure fact, lacking group experiments to confirm, but it appears to be the case.
Construction time: How long did the respective models take to build? Not measured.
Lines of Code: How verbose were the various programming methods? Most of the cases were able to be built using relatively small parametric definitions.
Latency: How quickly did code changes become geometry? The interactivity exhibited is
considered sufficient for these models specifically, more complex models should decrease their interactivity proportionally.

8. Code correctness exhibited in the experiments remains tolerably functional.

9. Design-simulation-fabrication processes are possible and an invaluable tool when designing programmable matter powered kinetic architecture structures using physical simulation models embedded in CAD/CAM software (both SMA and SMP), yet it is noticed that the learning curve is high and that it takes substantial amounts of time understanding the phenomena to model nonetheless they can be easily modified and reusable if structured correctly and orderly.

10. Vector control, in certain situations, can indeed replace geometrically defined IK solver methodology to “find” shape B in programmable matter kinetic applications, nonetheless, this method seems to have a handicap: it can become increasingly more difficult as complexity increments, therefore it is established empirically that form complexity and difficulty are directly proportional.

11. This approach (vector control), while intuitive and didactic, requires the user to “learn” or, better yet, be taught the physics behind the phenomenon by the Kangaroo engine itself (it was possible to achieve a double curvature surface without the mathematical equation).

12. It is proven that, in the case of kinetic architecture and programmable matter, visual
programming data-flow paradigms are the most intuitive tool yet developed, effectively
exhibiting more flexibility, easiness and real behavior modeling than the tools studied by
Angeliki Fotiadou (using 3Dmax).

13. More research and development is in order to further optimize this current method to simulate SMM and PM based KA. Special attention has to be put on molecular, numerical and multiscalar modeling in order to achieve more accurate and precise simulation outputs. In this experiments phase, a subdivided surface model was tried in order to abstract molecular formation, treating “strand to spring” experiment thread as a multi-agent solid mass model but the computer crashed and the model, just at the beginning of parametrically defining it, does not allow for interactive tinkering, thus making it unsuitable for design purposes, therefore this alternative was not pursued further. The crashing is attributed to a data overloading on RAM memory by the thousands of individual “dots” that made up the “strand”. Maybe a differently built parametric model could work yet this question is not answered accurately in this experiment, future work will include modeling molecular solid-mass models.


About kachoby

Independent Researcher, architecture and design. Hacktivist and social critic.
This entry was posted in Uncategorized and tagged . Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s