Natural Systems Studio by Luke Hickman

NATURAL

SYSTEMS

PROCESS

HACKER ARCHITECTURE

THEORY

SPECULATION Luke Hickman

Texture sourced from: http://ncertainties3.wordpress.com/tag/marc-fornes/

Contents

Introduction

I.1. Studio context

I.1.1. Preface

I.1.2. Studio approach

I.1.3. Initial Studio Ideas

I.1.4. Complexity and emergence

I.1.5. Programming and scripting

I.1.6. Natural Systems

I.2. Design context

I.2.1. Architecture as a field of ideas

I.2.2. Digital architectural design

I.2.3. Scripting Cultures

I.2.4. Bio-inspiration

I.2.5. Thinking Diagrams

I.2.6. I n i t i a l P r e c e d e n t S e a r c h

1. Marc Fornes,2012,Symmetries, The Very Many,Accessiblke Via: http://theverymany.com/ constructs/09-aperiodic-symmetries/img_8924_ pshop_c1_noc_tvm_s/

Contents

II. Research and Development

II.1. Natural systems

II.1.1.

Probability

II.1.2.

Subdividing Spring Network

II.1.3.A Forces

II.1.4.B Oscillations

II.1.5.C Particle Systems

II.1.6.

Autonomous Agents

II.1.7.

Cellular Automata

II.1.8.

Fractals

II.1.9.

Genetic Algorithms

II.1.10. Neural Networks

III. Conclusion

III.1. Learning achievements

III.2. Future work

IV. References V.

Appendix 1: Movies

VI. Appendix 2: Sketches 1. 1. Marc Fornes,2012,Vertebrae v2, The Very Many,Accessiblke Via: http://www.theverymany. net/uploaded_images/_-250_PShop2_TVM2-783177.jpg 2. Marc Fornes,2012,St Louis Plasti(k) v2, The Very Many,Accessiblke Via: http://theverymany. com/public-art/11-st-louis/_mg_4867_ps_tvm_s/

Natural Systems Studio Masters of Architecture Tutors:

Stanislav Roudavski Gwyllim Jahn

Author:

Luke Hickman

Student ID: 356 457 Institution: The University of Melbourne

I. Introduction

‘The Hacker Architect’ Craftsman of the Information Age An accumulation of tools allowing for the mining of complexity, and an open design dynamic feeding on integrated fields of study, will be referred to in this work as ‘Hacker Architecture’.

Thematic Image, SpaceSuit

1. Thematic image:- Hacker Culture as originating from the Cyborg fantasy, spaceflight... Source:http://bldgblog. blogspot.com.au/2011/04/spacesuit-interview-with-nicholas-de.html

Preface I.1.1.

Since, the 1990’s contemporary architectural discourse has been irreversibly ruptured by the digital tools revolution. A new design perspective is emerging which harnesses the generative and optimisation potential, of procedural and parametric computing. This new perspective is informed by the study of natural systems and the theory of “emergence”. The formal structure of this new design paradigm is bound by a dynamic relationship between two process typologies: 1) traditional, deterministic and linear processes, and 2) nonlinear, “emergent” and complex systems based processes. The combination of which prevails in practice as a hybrid design model. A relatively small avant garde of architects have begun to speculate on the potential for natural systems models to inspire a new era of innovative design, capable of meeting the increasingly salient challenges facing human inhabitation of the environment. Computer scripting languages and algorithmic thinking can provide access to this complex, non-hierarchical, and non-linear architectural frontier. A method of sourcing a diverse fi eld of ideas, simulating integrated design parameters, and validating selection criteria, could be most appropriately referred to as a ‘hack’. A ‘hacked’ solution is not dependent on its location in an empirical context, rather fi tness is determined by performance and the appropriate richness of the simulated environment. The state of the fi eld of scripting and generative processes integrating structural and material simulation, is in its relative infancy1. As well as being a language to encapsulate complexity, scripting has potential to bridge the creative divide between qualitative and quantitative design parameters, and open up new fertile architectural domains. An accumulation of tools allowing for the mining of complexity, and an open design dynamic feeding on integrated fi elds of study, will be referred to in this work as ‘Hacker Architecture’. 1 Hensel, M., Menges, A., & Weinstock, M. (2010). Emergent technologies and design : towards a biological paradigm for architecture. Abingdon, Oxon. : Routledge, 6

Adaptive Surface

I.1.2. Studio Approach

The studio impetus became a refl exive questioning of all design frameworks and their component parts; process, tool, design perspective and world view. At the start of this Natural Systems Studio my ideas were focussed on how scripting as a tool would effect the operation of architecture. 3.

Chaos

As the studio progressed the main themes of the studio became more tangible, and my theoretical approach was reformulated to encompass a multi-layered understanding of the studios goals. This layered understanding is built upon an appreciation of the language and qualities inherent in scripting and natural systems, that shape them as operational tools. The studio impetus became the refl exive questioning of all design frameworks and their component parts; process, tool, design perspective and world view. This refl ex was incited by the view of nature and evolutionary processes as performing “prolifi gate prototyping” and a “ruthless rejection of fl awed experiments”1 1. 1 Frazer, J. (1995). Introduction, An Evolutionary Architecture (Vol. Themes VII): Architectural Association Publications, 1.

2. Image created from Marc Fornes nCertainties Studio WorkShop, using rhinoScripting, represents the natural aesthetic, and performative materialism. Source: http://ncertainties. wordpress.com/blog/ 3. Thematic Image representing the qualities of noise and pattern, abstractly signifying the problematic inherent in deciphering and organsing scripted architectural processes. Source: Ibid 7

Initial studio ideas I.1.3.

My initial ideas for this studio were stimulated by the below statements in Emergent Technologies and Design: Towards a Biological Paradigm for Architecture1. “As mutations to the known form of organisms occur naturally, so too have the small innovations, theoretical ‘errors’ and design mutations of ancient architectures produced the ‘populations’ or cities of buildings, and driven the historical evolution of architecture.” “Other differences include the mode of inheritance, which in culture may be horizontal or oblique, as cultural practices concerned with material construction diffuse between distinct social groups”. These two statements made me think if culture can be re-analysed as a natural system, what new models of human development and potential could be divined? If culture is just another complex system linked with the metabolism of nature, and architecture is the representation of cultural forces, then a new architecture would be self referential of this change in perspective. My idea is to engage with a portion or slice of the cultural data stream and use this information to inform an architectural outcome. Scripting should provide a way to harness the massive redundant cultural code and utilize this database to invent procedure to enable spontaneous architectural ideas to emerge. The idea of coding architectural product to perform dynamically with the environment, follows the idea of emergence as it is applied to human culture. Architecture in this way is the environmental response of human agents interacting through cultural stimuli. This idea is elaborated in Michael Weinstock’s book The Architecture of Emergence, which explores the tendency of human culture to follow the a trend of increasing complexity2. He asserts that our culture will either learn to fi nd an equilibrium with nature, or there will be a collapse and an eventual re organisation. Eventually, human culture will develop and emergent equilibrium with the natural systems of the planet.

1 Hensel, M., Menges, A., & Weinstock, M. (2010). Emergent technologies and design : towards a biological paradigm for architecture. Abingdon, Oxon. : Routledge, 31 2 Weinstock, M. (2010). The architecture of emergence : the evolution of form in nature and civilisation. Chichester, U.K. : Wiley

4. Irene Neuwirth Jewelry

I.1.4. Complexity and emergence

Emergence is, “the arising of novel and coherent structures, patterns and properties during the process of self-organisation in complex systems”1. 1 Goldstein, J. (1999). Emergence as a Construct: History and Issues. Emergence: Complexity and Organization, 1(1), 49-72.

Apart from a new aesthetic generative approach, emergence and complex systems is argued by Michael Weinstock to be key, in understanding and planning a response to environmental pressures and the advance of “critical thresholds” forcing architectural innovation1. 1 (Weinstock, 2010)

Previous Page 4. Image created by Marc Fornes 2011 BOFFO Building Fashion Competition. Used for its aesthetic qualities Source:http://ncertainties3.wordpress.com/tag/ marc-fornes/

A fundamental perspective underpins a shift in architecture and contemporary culture, one that reconstitutes the fabric of matter towards a new paradigm of dynamic equilibrium. Matter exists in a turbulent process of thermodynamic phases. It is quantified by the micro-relationships of elementary parts within a grander systemic instability. The wholistic interpretation of this systemic narrative being defined by the term ”emergence”.

“The term system, in the context of architectural form and practice, serves as a synthesising concept by which the architectural system (form) can be seen as an integrated, spatial and material device, where its design is generated (in practice) by a computational system of algorithmic mechanisms operating to resolve internal and external performative criteria1. 1 Menges, A., & Ahlquist, S. (2011, 13-16 Octobe). Behavior - based Computational Design Methodolgies, Integrative Processes for force defined material structures. Paper presented at the ACADIA, Banff Canada, 83.

Complexity and emergence cont. I.1.4.

The new governing paradigm for architecture is the formative imagined processes organising fitness of a design. This is and extended theoretical problem caused by the destabilisation of knowledge. A “multiplicitous”1 view of matter and knowledge results in a scenario where “...any serious system will generate an almost unmanageable quantity of permutations”2. The challenge for architecture is organising this non-linear topology of design versions and mutations.

1 Deleuze, G., & Guattari, F. (1987). A thousand plateaus: Capitalism and schizophrenia: Burns & Oates. 2 (Frazer, 1995, 14)

Kleiburg housing project

“When a certain critical mass of complexity is reached, objects can self-organise and self reproduce in an open-ended fashion, not only creating their equals but also parenting more compleicated objects than themselves.”1. 1 (Frazer, 1995)

It is important to de mystify scripting and its corollary with evolutionary architecture, it is not about being playing god, instead it is a more humble perspective based on accepting complexity and trying to work with it1. 1 (Frazer, 1995)

I.1.5. Programming and scripting Algorithms and scripting is the language construct of complexity and “massive data”. “...massive data as the new agnostic tool gives us the space to go beyond theories and nostalgic semantics...” “...massive data is the new meaning.”1.

1 Ottchen, C. (2009). The Future of Information Modelling and the End of Theory: Less is Limited, More is Different. Architectural Design, 79(2), 22-27. doi: 10.1002/ad.845

Scripting is an important link tool and language for containing complexity. Scripting has at its core the function of describing and threading together algorithms that can organise and translate massive amounts of data into a cohesive and humanly perceivable form. Previous Page 5. Depicts a visual outcome generated using parametric design, which facilitates greater control over a complex and co-dependent parameter set. The dynamics of a facades function in relation to light, heat, ventilation, views, and aesthetic modulation is typical of architectural complexity. Greg Lynn, Kleiburg housing project, Bijlmermeer, the Netherlands, 2006

Why use and learn scripting? It is necessary to be able to customise your own design tools. Greg Lynn explains his use of scripting as the inevitable outcome of the need to get the results your design intuition requires. “ Intuition is the moment when the principles and techniques of a discipline are so integrated that one is able to extrapolate, develop and extend them as an invention or innovation”1 . 1 Rocker, I. M. (2006). CalculusBased Form: An Interview with Greg Lynn. Architectural Design (London, England), 76(4), 88-95.

The architect is becoming a catalyst for design, rather than a dictatorial author. Via information transfer through an algorithm, the static object has been replaced by a focussed procedure incorporating flux. “In its most benign sense, the algorithm in a design process is the problem-solving route conforming to a set of rules guiding towards a satisfactory or ‘good enough’ solution”1.

1 Burry, M. (2011), Scripting Cultures: John Wiley & Sons, 79 11

Natural Systems I.1.6. Use natural systems as “hunter seekers” of design richness and complexity1. 1 Miller, P., & Joachim, M. (Producer). ( 2011). Music and The Metrics of Happiness. [Seminar] Retrieved from http://www.youtube.com/ watch?v=ooUlrsvjDIE

“Within the contemporary landscape of architectural discourse there are two divergent trends with theoretical motivations: the morphdynamical and the morphogenetic systems approaches to the design and construction of buildings” this bifurcation is mirrored within the biological fields. “After more than half a century of engagement with the avant garde, the practice of architecture has become increasingly conscious of its embeddedness within the general economy of forces, relationships and the global economy”1. What remains salient is the requirement for the avant garde to push deeper into the morphogenetic, and develop signification and a meaning system behind natural systems models. 1 Chu, K. (2006). Metaphysics of genetic architecture and computation. Architectural Design, 76(4), 38-45. doi: 10.1002/ad.292

“This new research proceeds from the recognition of architectural constructions not as singular and fixed bodies, but as complex metabolic and intelligent material systems that have a finite lifespan, that are interlinked as part of the environment of other active systems, and that can be symbiotically related to the flow of energy and material in the systems and processes of the natural world”1. 1 (Hensel, Menges,Weinstock,2010)

How to use natural systems for the simulation of architectural problems? Design the environment before you design the object. Architectural processes are considered as consisting of an assemblage of parts, constructed from a organisational code (DNA), constrained by its environmental context, and formulated via the complex inter-relationships between small scale components acting within layered systems, and within the environment. Once architecture is conceived as existing in this dynamic assemblage, it is a case of designing an appropriate simulation, morphology of component parts, elementary behaviours and environmental effects. From which design versions can be selected, whilst maintaining the important perspective of the limitations to a simulation and the bias of the designer.

Geranium stem

6. Image of a Geranium Stem, â&#x20AC;&#x153;The emergence of individual parts bind together to create a remarkable geranium stemâ&#x20AC;?. Source:http://michelletiffin. wordpress.com/2011/04/10/396/ 13

Design context I.2.

The rapidly expanding range of digital tools, can both limit and expand design imagination. What is shaping contemporary design context, is the question of authorship and control over the design process.

Computational design is functionally different from the use of “pre-packaged processes”, as it “focuses on a ‘meta - design’ of fundamental behaviours and principals(Coons, 1963)”1. More importantly a rigorous internal

scepticism must be cultivated,

aimed at questioning underlying design motives as well as the constraints of digital tools. 1 Menges, A., & Ahlquist, S. (2011, 13-16 Octobe). Behavior - based Computational Design Methodolgies, Integrative Processes for force defined material structures. Paper presented at the ACADIA, Banff Canada.

I.2.1. Architecture as a field of ideas

Whilst architecture seems to be undergoing a resurgence in quantifiable determinism, founded on the mining of large data sets, simulated behaviours, environmental systems, and algorithmically defined process. The fact remains; intuition and the black box of a designers mind still prompts and wholistically confines any design investigation. Further, to have a complete “contextual input”, towards any design problem, is computationally unfeasible. The magnitude of real world complexity, and possible emergent outcomes, forces the creative process to be a strategic one.

“This encompasses a vastly integrative view of design process which includes the synchronous development in forming the meta-framework, the programmed behavior-based processes, and the iterative triggering of the design generating system. The systems based approach begins to register a direct, not representational, connection towards a view of architecture as dynamic in its response to material resources, behaviors, and contextual input”1. 1

(Ahlquist, Menges, 2011, 88)

The avant garde approach to computational design, differs from “design processes which function upon collective generalizations”, firstly in its meta - philosophical stance of the ‘multiplicitous’, infinite set, or Gödelization of design schema, and secondly by its re valuation of mathematical, and scientific method, as a requisite of “good” design. However, the fallacy of generative or computational design, as an autonomous, synthetic design system, is made apparent by its reliance on ‘input’, algorithmic specification, and human selective reasoning. 15

Digital architectural design I.2.2.

Digital architecture can be crudely separated into two distinct operational methods; one depicted by its use of the generative algorithm for formal derivation, which can be termed ‘generative design, and the second; parametricism being differentiated by its isolation of the computational algorithm to optimisation only, instead, intuiting form via deterministic, sculptural means. The validity of algorithmic processes to generate appropriate and satisfactory design outcomes, with a repeatable authorship, is uncertain. However, the future of digital design and architecture in general is enriched by this problematic of both authorship, control and its generative potential. Generative design can be a ‘black box’, whereby “...algorithms speed up design discovery, but [are] always tuned to the logical processes enshrined within...”, and as a result can grow into unmanageable complexity.1 1 (Burry, 2011)

Where is digital design going? “Architecture is considered as a form of artificial life, subject, like the natural world, to principals of morphogenesis, genetic coding, replication and selection”1. Is architecture becoming more like science or has architecture spawned a new affective scientific discourse? “Perhaps before the turn of the century there will be a new branch of science concerned with creative morphology and intentionality”. 1 (Frazer,1995)

It is not about autonomous design systems, but about “prolifigate prototyping” that assists and turbo charges the traditional creative strategies used within architecture1. It is a way of externalising the design processes that traditionally are contained within the mind of the architect and through analog representations. 1 (Frazer,1995)

I.2.3.

Scripting Cultures

“I am, however, particularly attracted to the situation where computational support is used to steer the design towards simplexity being enlisted as an external agent to counter the human tendency towards complexifi cation”(Burry, 2011, 75). Mark Burry discusses the internal problematic of scripting for architectural generation in his book Scripting Cultures. The problem is where an idea may or may not be better when it originates and is propagated in the mind compared to being directly insinuated by a computational process (Burry, 2011).

“But, just as in the new ‘softer science’, algorithms assume the burden of rigorous quantitative methodology and the mind is left ‘free to move around the data in the most creative way’. Technically this implies a broader use of creative scripting in the initial stages of design,...we should strive for seamless interoperability - without loss of metadata - between scripting protocols, the more pragmattic stages of BIM and a variety of analytical software”1. 1 (Ottchen, 2009, 25)

The architecture of the “Adjacent Possible” 7.

1-d cellular automata

7. Image created by Karl Chu, From Metaphysics of Genetic Architecture and Computation, a Planetary automata based on 1-d cellular automata. The world of and culture can be populated by an algorithmic landscape of ideas and form.

Hacker architecture is an urge to expand into a networked, interactive universe of unimaginable potentials. Stuart Kauffman in Karl Chu’s essay Metaphysics of Genetic Architecture and Computation states; “The universe has not explored all possible kinds of people, legal systems, economies or other complex systems’, and that ‘autonomous Agents tend to arrange work and coordination so that they are expanding into Adjacent Possible as fast as they can get away with it”1. 1

(Chu, 2006, 39)

Architecture can incorporate the hacker culture of open systems and non-linear, communication pathways. From this view point, architecture must not impose idea models, rather use the ‘soft’ data and ‘soft’ science approach to form fi nding,so that a best fi t design, between cultural and biological contexts can be uncovered1. 1 (Ottchen, 2009) 17

Bio-inspiration I.2.4.

“...Not only has biology become indispensable for building but building for biology.” (Otto 1971: 7-8)

Dispel the myth of “creating life”. It is important to not invest nature with human intentions and a singular intelligence. Nature does not design. Design is fundamentally a human behaviour, and in a sense, a symptom of our ‘selfish’ vitality and tendency to anthropomorphism1. 1 (Frazer, 1995)

Natural Models as a facility for architecture. •Is consistent with the use of mathematical models in contemporary practice. •Architectural form that exhibits behaviour. •Reconnecting design and production. •Incorporation of time into the design process. •Variant forms responding to environmental conditions. •Derive design from living systems. •Material properties. •Metabolism •Adaptive responses

Bio-inspiration has become a necessity in order for human culture to sustain itself within an environment it has become irreversibly entangled with. Evolution as the foundation principal of biology can infer a new architectural culture, that derives value from the synthetic emergence of material properties, metabolistic synchronicity and adaptive responses1. 1 (Hensel et al,2010, 11)

The key to why natural models are of pertinence to architecture is that they contain the qualities of; many parts, open systems, adaptation, “irreversible histories”, “hierarchic pattern” and a “variety of complex, non-linear dynamics”. Not only does this makeup exhibit similarities with contemporary architectural practice but provides a model for innovation1. 1(Hensel et al,2010, 11)

Is the problematic defined by the mode and extent of design authorship?

Deterministic

Emergence

Creative Genius

Natural Systems Model 8. Emergence and Determinism Diagram

A hybrid perspective informed by parametricism and the natural systems model.

Creative Genius World View Design Perspective

Natural Systems Model

Tools

Deterministic

Hybrid

Emergent design or Noise

Coherence

Pattern Recognition

Design Perspective

9. Coherence and Noise Diagram

The ability to more broadly farm parameter space

Design Perspective

Tools Simulation Digital

Constraints

Analog Hybrid

P 10. Farming Parameter Space

Parameter Space P

= Potential Design Solutions

Future

Historical Perspective

Artificial Authorship

Motivating Artificial Intelligence Hacker Architecture You are here?

Hybrid <Parametric Organicism>

Sourcing from emergent processes Parametricism

Authoring the system Direct Authorship

Manipulating parameter sub - components

11. Subjective View of Discourse History

Parametricism versus the Natural Systems Model and tools

Generative Tool Natural Systems Model

Computer Coding / Scripting / Programming

Optimisation Tool Parametricism

Optimisation Tool

Generative Tool Direct Manipulation of 3d form via predefined shape/pattern authoring tools

12. Natural Systems v Paremtricism

“Architecture is seen as a form of artificial life, subject like the natural world, to principals of morphogenesis, genetic coding, replication and selection”(Frazer). It is not so much about autonomous design, rather about “prolifigate prototyping” that turbo charges traditional creative strategies. It is a way of externalising portions of the design process, that would normally be contained within the mind of the architect.

“Instead of muchcriticized rigidity that is seen as a typical property of digital tools, this relationship is not dissimilar to that between a designer and a paper sketch. Through multiple iterations and refinement, the voluntary input is calibrated against meaning already invested into the system. Thus, calculable numeric data aquires the exploratory suggestive capacity that sets up a dialogical relationship between multiple versions generated in response to modified input and sets the ground for the discovery of new form”(Artopoulos,Roudavsk i,Penz,2005) 23

I n i t i a l P r e c e d e n t S e a r c h I.2.6.

The core problematic of architecture From frazer evolutionary arch

Generation

Selection

Turing

Basic of life is information

Von Neuman

new perspective of matters as existing in a state far from equilibrium Not nature

Ilya Prigogine

nature does not design

Anthropromorphism to - genes ‘selfish’ tendencies

Anthropromorphised, vitalist perspective

Nature Model Provides a new ‘selfish’ selection process Test of fitness

In a way architecture is about pre dicting the future, virtualizing the complex formative environment to find the fittest performing result.

Validation Adaption Nature does not throw away the tool box “Ruthless rejection of flawed experiments” “Prolifigate Prototyping”

13. Core Problematic of Architecture

“Mitchell regards architectural design as a special kind of problem-solving process. This approach has limitations which he recognises in principal. First, it assumes we can con struct some kind of representation which can achieve different states that can be searched through for permutations corresponding to some specified criterion (the criterion of the problem). Unfortunately for this goal-directed approach, it is notoriously difficult to describe architecture in these terms, except in the very limited sense of an architectural brief to which there are endless potential solutions. The other problem is that any seri ous system will generate an almost unmanage able quanity of permutations.

I.2.6.

In itial Precedent S e a r c h

This source discusses how Architecture should not impose form, but through stochastic principals (applied mathematics) and sourcing the “massive data” of the contemporary world, find new strategies that incorporate both “soft data” (qualitative cultural information) and objective data to design effective (performative) architecture. Cynthia Ottchen proposes that there are two separate trends within architecture; the use of animation like software to create fluid dynamic shapes and morphogenetic outcomes, and the productivity tool / BIM approach where documentation and project management is prioritized1. Ottchen explains that a new way of thinking will arise to bridge this traditional divide between the “romantic/rational” portions of architecture. This new bridging theory will enable architecture to engage the complex world in an “effective” way defined by stochastic principals that through the raw power of data and computing capacity can originate ‘fit’, adapted results. 14.

Photographic Tower Iterations

She describes a new role for the architect as a “multidisciplinary strategist”. 1 (Ottchen, 2009)

15. This image of the Photographic Tower Iterations depicts how form finding can include a mode of malleable points linked to parametric controls.

Initial Precedent Search

This post graduate research project set in Santurce/San Juan Puerto Rico was based on developing urban scale synthetic models of the stocks and flows of economic and social forces within an urban field of interest. The students used computational models to break hierarchic topologies and reorder and develop non-linear, inventive program and spatial relationships. The winning master plan for the studio work synthesized a broad spectrum of competing hierarchical parameters such as bodies of water, transport paths and flows and zoning regulations. This project shows that scripting can be a powerful tool in collecting and diagramming complex design problems particularly on an urban scale. Even though the figural result may be highly conceptual its use as a diagram is profound1. Web Morphogenesis (see fig 1) is an example of a project that was inserted into the master plan. This project interestingly states that it is not form that follows function but the result of form in dialogue with function. With scripting both can compete and be manipulated non-hierarchically. It uses a â&#x20AC;&#x153;multi-agent based system working with curves, force fields and rules for a woven structure combined with rules for filling space through subdivision.â&#x20AC;? 1 Dubbeldam, W., Snooks, R., & Kolatan, F. (2011). New Normal Retrieved from http:// issuu.com/archworkpenndesign/docs/pppd , p 37 -49

15.

Systemic Compulsion

I.2.6.

16.

Web Morphogenesis 27

Research and Development II.

II.1. Natural systems

Probability II.1.1.

“Let us build machines that can learn, can grope and can fumble, machines that will be architecture partners, architecture machines”(Negroponte, 1970)1 1 (Özgür, 2009)

Probability as method within computational design provides a function whereby computer defined randomness can be used to represent variance that would naturally occur in the physical world. Probability can also be used to describe a wandering from a predetermined parameter set, enabling the designer to source versions otherwise inaccessible with analog processes. Probability and stochastic design is at the core of the generative or computation design initiative, as it represents the integration of mathematical and biological models into architectural discourse, such as chaos theory and neo-darwinism.

It could be argued that probability is a necessary element of intelligence. When applied as a search procedure spanning potential connections, and combined with a selection routine, a working pattern can be derived, which maps the probable solutions to a particular design problem. Probability combined with human intelligence (as a selection tool) can use “...computers [as] intellectual machines that allow us to simulate human behavior”(Negroponte, 1970)1 1 (Özgür, 2009)

“...the designer’s new role is to provide the “intelligence” that is the core of a set of design rules, while the computer provides for calculating power and randomness”. “This process has been referred to as the computer’s potential to become “an active creative partner in design”(Shea, 2004)1. 1 Özgür, E. (2009, 16-19 September). “Improvising” Architecture: A Fractal Based Approach. Paper presented at the eCAADe Istanbul (Turkey).

II.1.1. Probability

17.

Chaos Diagram

Bacterial Walker

The aim of this sketch was to design a process whereby particles explored and clustered the inert environment, then were organised via a selection process and made to change in some way. The initial idea was for it to be a model of human expansion and settlement across a landscape. Once a certain amount of particles in a zone was reached a new exploration team would be sent off. These ideas were too advanced at the time of this journal entry. The end result used a random step action and a selection routine highlighting particles with a specifi c opacity.

(A) Probability used to structure movement of an agent (B) Graphics used to select and visually mark certain characteristics of an agent

//RAW CODE

// Code that isolated and highlights specifi c particles. First step toward selection.

(B)

void display() { //additional data -object functions noStroke(); if (opacity < 150) { opacity = 255; } fi ll(random(c),0,0,opacity--); ellipse(x,y,r1,r1); if(c>252){ stroke(0,255,0,opacity--); ellipse(x,y,r1*2,r1*2); colormatch = true; }} //random walker code

(A)

void step() { // randomly steps the object from center if hits edge int choice = int(random(6)); // the random choice of if (choice == 0) { //number between 0-3 determines step x= x + 10; } else if (choice ==1) { x= x -10; } else if (choice ==2) { y = y + 10; } else if (choice == 3){ y=y -10; } if (choice == 4) { /number between 0-3 determines step x= x + 20; } if (choice == 5) { //number between 0-3 determines step x= x - 20; } else { y = y+ 20;} if (( x > width) || (x < 0)) { // reverts to near center pos x = width/2*z; } if (( y > height) || (y < 0)){ // reverts to near center pos y = height/2*z; } }//end method

18. Baterial Walker Code Snippet

19. Baterial Walker Processing Image Exports 33

Life and Death

This processing sketch was made under the parameters of learning to use arraylists and vectors. The particles randomly move through a set velocity variable and are contained within the screen boundaries. The complex visual representation is achieved via cross checking distances between individual particles so that a joining line can be drawn between them. This simple method instantly created a sense of architecture even if it is quite ‘dumb’. The sketch is made more interesting via the addition of two environmental zones, a life zone whereby a particle is added once crossed and a death zone where a particle is removed. Sliders were used to alter the size of these zones and get different behaviour.

(A)

if (mousePressed) { Vec3D p = new Vec3D(mouseX, mouseY, 0); Spot newSpot = new Spot(p); spotcollection.add(newSpot); } for (int i = 0; i < spotcollection.size(); i ++) { Spot ms = (Spot) spotcollection.get(i); ms.run(); ms.die(); ms.live(); } if (spotcollection.size() > 500 ) { noLoop(); } for (int i = 0; i < deleteList.size(); i ++)

{

(B)

(A)

Learn’t about the need for multiple arraylists to manage dynamic list references, so that there are no errors.

(B)

Learn’t about the concept of references and indexes.

//RAW CODE

void draw () { background(0); //call functionality addList = new ArrayList(); deleteList = new ArrayList();

Spot msd = (Spot) deleteList.get(i); // when you take something out of a list //need to give it a new name so the comp //knows what it is.

int spotIndex = spotcollection. indexOf(msd); //get the index of the objects //called from the deleteList //remove objects at index which is //defi ned by variable just added. spotcollection.remove(spotIndex); } //then run the add code //ditto, loop through the stuff in the add list, //and add to the //spotcollection list for (int i = 0; i < addList.size(); i ++) { Spot msa = (Spot) addList.get(i); spotcollection.add(msa); } } } 20.

Life & Death Code Snippet

(A) Zone deleting particles from arraylist 21.

Life & Death Processing Image Export

(B)

Simple lines between points, represent relationships 35

Culture Genotype

This sketch was started from the abstract idea that in the future culture as a living instance or suspended artifact could be analysed and mapped in all its scope. This sketch uses a random walker that was to have varying characteristics and interactive behaviors like explore, cluster, kill and breed to simulate the growth of cultural elements and their inter-connectedness. At the time of this journal the sketch was working upon the principals of explore and cluster. The cluster behaviour simulated convergent cultural elements and the exploring behaviour cultural modes of distinction. The explore behaviour fed back into the system shocking the clustered elements with a greater acceleration once a certain escape distance was reached.

// Main walker characteristic set of functions void tendancies() { display(); update(); explore(); //parametric selection or (probability) // of population avoid clusters, accelerate away cluster(); //parametric selection //(probability) (A)

(A) When one agent reached the box boundary all agents would receive an acceleration (B) Particles cluster when within range of each other

(B)

void explore () { if (explorergo) { for (int i = 0; i < Ws.size(); i++) { Walker explorer = (Walker)Ws.get(i); Vec3D kickstart = new Vec3D (random(-10, 10), random(-10, 10), random(-10, 10)); fl oat bounds = loc. distanceTo(explorer.loc); if ( bounds > 50) { acc.addSelf(kickstart); } }}} void cluster () { //create a time switch so only happens //once each cycle if (frameCount == 100 && clustergo) { for (int i = 0; i < Ws.size(); i = i + isov) { Walker other = (Walker) Ws.get(i); fl oat clusterdist = loc. distanceTo(other.loc); //if within range of pull then particles drift together if (clusterdist > 0 && clusterdist < neighbourdistance) { acc.addSelf(other.loc); acc.clear(); clustergo = false; //switch off println(â&#x20AC;&#x153;clusteredâ&#x20AC;?); } } }} 22.

//RAW CODE

Culture Genotype code snippet

23.

Culture Genotype processing image export

Subdividing Spring Network II.1.2.

â&#x20AC;&#x153;The design process acquires a character of an investigative tool rather than that of a method with which a wilfull author promotes his or her world viewâ&#x20AC;?. (Artopoulos, Roudavski, Penz, 2005).

Goal:

Create a surface that lives in a physical world with gravity and fric tion. The surface is to be connected by a grid of springs that act with oscilla tions to resist forces. Each spring is made of two particles that react to the physical environment and box constraints. Create a method where the spring strain is tested. If a spring is strained then that spring and its immediate neighbours undergo subdivision. Strained springs are removed and smaller connective springs are cre ated.

II.1.2. Subdividing Spring Network

â&#x20AC;&#x153;The sacrifi ce of arbitrary control leads to gains in the capacity to deal with complex systems as systems, without reducing them to basic componentsâ&#x20AC;?. (Artopoulos, Roudavski, Penz, 2005).

The original idea was spawned from the rudimentary idea that virtualized forces could describe and organisation of compartments in space. The idea was to automate, an emergent space organisation tool. The initial plan was to use a spring network as a trace object that reacted to an agent system permeating an environment. The spring network would have nodes which located the spatial compartment and would reconfigure to best fit within the paradigm of complex integrative virtual forces.

Genesis:

This idea was found to be too complex when using the combination of agents with a spring network.

Subdividing Spring Network II.1.2.

“Through multiple iterations and refi nement, the voluntary input is calibrated against meaning already invested in the system”. (Artopoulos, Roudavski, Penz, 2005).

The base surface is imported via the use of an existing toxiclib library tool that converts a rhino plane (geometry) into an stl file. This stl file is then converted into a mesh surface with triangular faces, edges and vertex components.

Process:

The hope was to use the toxiclib’s mesh interface to control and track the subdivision process. However, issues were found in aligning the mesh vertices with the physics engine during update of the meshes position. Extensive coded trial and error proceeded. The ‘hacked’ solution was create a custom springFace component that could reference the physics particles and update the springs. The mesh was removed. 3 types of sub-

division were experimented with. 40

II.1.2. Subdividing Spring Network

â&#x20AC;&#x153;Thus calculable numeric data acquires the exploratory suggestive capacity that sets up a dialogical relationship between multiple version generated in response to modifi ed input and sets the ground for discovery of new formâ&#x20AC;?. (Artopoulos, Roudavski, Penz, 2005).

24. Spring Subdivision Diagram

Process:

3 types of subdision.

Subdividing Spring Network II.1.2. //class to keep track of 3 x vertlet particles //and 3 springs //construct the springFace using the properties of the //original WEFaces from the imported stl to mesh in setup phase //will need to run through the faces and get the verletParticles at the vertex points public class springFace { List<VerletParticle> nodeList = new ArrayList<VerletParticle>();

(A)

//constructor springFace(VerletParticle _n1, VerletParticle _n2, VerletParticle _n3) { nodeList.add(_n1); nodeList.add(_n2); nodeList.add(_n3); } public VerletParticle getOther(VerletSpring _ss) { //run through particle list, if no equal to ss.a or ss.b then return particle for (VerletParticle n : nodeList) { if( n != _ss.a || n != _ss.b) { return n; }} return null;} public boolean checkV(Face f) { if( (f.a == nodeList.get(0).getPreviousPosition() || f.a == nodeList. get(1).getPreviousPosition() || f.a == nodeList.get(2).getPreviousPosition() ) && (f.b == nodeList.get(0).getPreviousPosition() || f.b == nodeList.get(1). getPreviousPosition() || f.b == nodeList.get(2).getPreviousPosition() ) && (f.c == nodeList.get(0).getPreviousPosition() || f.c == nodeList.get(1). getPreviousPosition() || f.c == nodeList.get(2).getPreviousPosition() ) ) { return true; } if( (f.a != nodeList.get(0).getPreviousPosition() || f.a != nodeList.get(1).getPreviousPosition() || f.a != nodeList.get(2).getPreviousPosition() ) && (f.b != nodeList.get(0).getPreviousPosition() || f.b != nodeList.get(1). getPreviousPosition() || f.b != nodeList.get(2).getPreviousPosition() ) && (f.c != nodeList.get(0).getPreviousPosition() || f.c != nodeList.get(1). getPreviousPosition() || f.c != nodeList.get(2).getPreviousPosition() ) ) { return false; } else { return true; } }}

(B)

25. SubDiv Spring code snippet 1

(A) Key to navigating a network was creating a face class that stored node connections between spring ends

(B) Created a custom function for checking whether the navigation class contained the nodes in question. Returns true or false. This allows the update cycle to search for the navigation faces that contain shared nodes.

II.1.2. Subdividing Spring Network /*********************************** function to subdivide springs **********************************/ void subdivSprings() { //get strained spring s from hashmap with corresponding Wingededge fl oat rand = random(1); if ( rand < 1) { //has to be a shared edge if (strainedSprings.isEmpty() == false) { (A) for (VerletSpring ss : strainedSprings) { if (ss.a.getPreviousPosition().distanceTo(ss.b.getPreviousPosition()) > minDist) { //action spring must be shared by two springFaces int sFshare = 0; //get the two springFaces that contain vec3ds for the end points of strained spring for (springFace sF : springFaces) { (B) if (sF.nodeList.contains(ss.a) && sF.nodeList.contains(ss.b)) { sFshare++; //if there are two spring face that contain it. if (sFshare == 2) { for (VerletParticle p : sF.nodeList) { if ( p != ss.a || p != ss.b) { VerletParticle pgood = p; //fi nd 3 midpoints //get midpoint1 of strained spring (C) Vec3D mp1 = ss.a.interpolateTo(ss.b, .5); //get midpoint2 of other spring in springFace Vec3D mp2 = ss.a.interpolateTo(pgood, .5); //get midpoint3 of other spring in springFace Vec3D mp3 = ss.b.interpolateTo(pgood, .5); //add new physics particle add midpoint of strained string Node n1 = new Node(mp1); Network.add(n1); physics.addParticle(n1); Node n2 = new Node(mp2); Network.add(n2); physics.addParticle(n2); Node n3 = new Node(mp3); 26. SubDiv Spring Network.add(n3); code snippet 2 physics.addParticle(n3);

(A)

A previous function tests all the springs in the network and adds them to a strained spring list. This list is then used to navigate the network and create and delete springs and navigation faces (springFaces)

(B)

This loop tests whether a spring which contains to nodes is shared by two springFaces. If it is then subdivision will occur. This prevents the network from breaking apart on the edges.

(C)

Strained springs are divided in two, using the midpoint which is found using Toxiclibs function interpolate. Then this new point on the subdivided spring is added as a physics particle to the physics engine. 43

Subdividing Spring Network II.1.2. /////////////////create 9 springs///////////////////////////// //Spring 1 - cross brace spring if ( physics.getSpring(ss.a.getPreviousPosition(), n1.getPreviousPosition()) == null) { VerletSpring otherSpring = new VerletSpring(ss.a, n1, ss.a.distanceTo(n1), springStrength); physics.addSpring(otherSpring); springCount = springCount +1; } //springs 2 - 8 here //Spring 9 if ( physics.getSpring(n3.getPreviousPosition(), n2.getPreviousPosition()) == null) { VerletSpring s2 = new VerletSpring(n3, n2, n3.distanceTo(n2), springStrength); physics.addSpring(s2); springCount = springCount +1; } ////////////////////del 3 perimeter springs/////////////////////////////

(A)

(B) springsDel.add(ss); springsDel.add(physics.getSpring(ss.a.getPreviousPosition(), pgood.getPreviousPosition())); springsDel.add(physics.getSpring(ss.b.getPreviousPosition(), pgood.getPreviousPosition()));

///////////////////////this creates 4 new springFaces////////////////// //springFaces keep track of verletparticle triplets springFace sF1 = new springFace(sF.getOther(ss), n2, n3); (C) springFace sF2 = new springFace(n3, ss.b, n1); springFace sF3 = new springFace(n2, n1, n3); springFace sF4 = new springFace(n1, n2, ss.a); springFacesAdd.add(sF1); springFacesAdd.add(sF2); springFacesAdd.add(sF3); springFacesAdd.add(sF4);

}

else { return; }

springFacesDel.add(sF); } } } } } }}}}

27. SubDiv Spring code snippet 3

(A)

use the Toxiclibs physics function to search for the springs, using the node or physics particle location as a marker. Use the nodes located by the springFace (Navigation Face) and newly created midpoints, and existing nodes to make new springs.

(B)

Add strained springs to a list for deletion in another loop, to avoid a concurrent modifi cation error.

(C)

Create new navigation faces (springFaces) to keep track of the newly created springs. Add these to list containing all springFaces.

II.1.2. Subdividing Spring Network

28.

SubDiv springnetowrk processing image export

29.

Subdividing Spring Network

30.

Subdividing Spring Network

Predators and Prey Dynamic construction of form with agent swarms

This week I looked at add attraction behaviors to agents and using arraylists to add and remove objects.

I need to add avoidance, cohesion and separation to the prey class, so that could mimic predator and prey behaviour. The main outcome of this sketch was learning how to implements communication between classes and hence interaction between differing agents. The sketch seen heres only exhibits attraction of the predators towards the prey. When a predator hits the prey the agent is removed. This coordination required multiple arraylists and an understanding of indexes and references to an object.

31. Predator and Prey close up processing image export 1

32. Predator and Prey close up processing image export 2

(A) Attraction behaviour not based on Craig Reynoldâ&#x20AC;&#x2122;s steering behaviours, hence predator agents cluster and do not follow the red prey particles. (B)

Structural issues with code. Learning about arraylists and the need for steering behaviours

Predators and Prey

(A) No emergence, the result is noise. However, artistic outcomes can result from direct manipulation of simple tools.

This is the same predator and prey sketch where I turn off the background in the draw loop. This allows for a mapping or tracing of the predator movement as the prey visibility was turned off. The behaviour is a nuclearisation of the predators, as they are attractor to multiple prey objects surrounding them in a dense fi eld.

33. Predator and Prey close up processing image export 3

The extension of this project would be to use two confl icting object classes to provide data for mapping a surface or structure. For example the predator movement across a grid could manipulate height fi eld of lines which have origin points mapped to the prey locations.

34. Predator and Prey close up processing image export 4

31-34. See PredatorandPrey_1, - frame 200- 1500

Autonomous Agents II.1.5.

Why use Stigmergy? Agents with simple-stimulus reaction rules, interacting in a local neighbour hood of information. The agents can act on the inforamtion in two ways:

Stigmergy is derived from concepts that classify “mechanisms the mediate interactions between social organisms”1. Stigmergy as an architectural tool in parallel with other natural systems like swarm behaviour and plant growth rules can provide a tool for aligning architectural production with the limits of an ecological system, whilst informing more effective structures and new aesthetic modes.2 1 Jason Lim, 2011, Let’s Work Together: A Stigmergic Approach to Acoustic Design, in Integration Through Computation, ETH Zurich, Aterlier Panda, ACADIA 2011 Proceedings, 396 2 Mammen, S. v., & Jacob, C. (2008). Swarm-driven idea models- From insect nests to modern architecture. Retrieved from vonmammen.org/science/eco-architecture-2008.pdf

1. Qualitative, specifi c environmental data structures trigger behaviour. 2. Quantitative, the intensity of stimulus correlates with triggered behaviours.1 1 Mammen, S. v., & Jacob, C. (2008). Swarm-driven idea models- From insect nests to modern architecture. Retrieved from vonmammen.org/science/eco-architecture-2008.pdf

31 & 32. A project by Luis Quinones for a year 2040 lunar outpost, generated by resource dependent human stigmergy.An example of designed stigmergy. Source:/ http://www.suckerpunchdaily. com/2010/07/05/2040-lunar-outpost-a/

35.

Stigmergy Thematic Image 1

II.1.5.

36.

Autonomous Agents

Stigmergy Thematic image 2

Stigmergy provides a direct method for implementing a feedback loop between an agent and the environment. The aim is to achieve a relative equilibrium and an emergent pattern.

//PSEUDO CODE Global Variables -Declare world environment -Declare ArrayList of Agents systems

Aims: -Implement basic stigmergy -Explore base image imports -Explore blank image behaviour -Explore search behaviour variables -Implement a particle system for agents

Setup -Initialise Agent system container -Initialise the environment Draw -Option to load image as background environment -Background pixels loaded into an array, so can be manipulated -Background slowly fades back to black -Agents run their functions. -Agents search for brightest, or most white pixel -Agents modify the background enviroment, leave a white trace

Class Agent -Contains properties to describe movement -Had custom behaviours: -Stays within the world - checks edges -Searches the pixels around itself -Moves towards best pixel -Modifies pixels underneath itself

Trying to re-create in essence the forms emergent from the stigmergic behaviour of social insects like termites. However, termites follow different and more complex processes. This sketch only takes into account the path following behaviour of termites.

37.

Stigmergy Processing Image Export 1

(A) View of the intial seeding of the sketch (B) A proper functioning stigmergy sketch using a low speed and a search radius of 20 (C) Condensed view of the same sketch

38. Stigmergy Processing Image Export 2 52

39. Stigmergy Processing Image Export 3

II.1.5.

Stigmergy

//RAW CODE

//check the environment around the object void checkWorld(){ PVector toBest = new PVector(); //create a temp vector to //keep track of the direction of the best //condition fl oat maxV = 0; //loop through pixels for (int i = -searchRad; i<=searchRad;i++){ for (int j = -searchRad; j<=searchRad;j++){ if(!(i==0 && j==0)){ //checks for edges int x = fl oor(location.x)+i; //’fl oor’- //Calculates the // closest int value that is less than or //equal to the // value of the parameter x = constrain(x,0,width-1); // // constrain(value, min, max) int y = fl oor(location.y)+j; y = constrain(y,0,height-1); //check to see if this is the smallest //current value //scale by the distance to the value fl oat v = world.getAt(x,y); PVector toV = new PVector(i,j); //limit the angle of vision if(PVector.angleBetween (toV,velocity)<PI/2){ //check to see if the current value is larger than //the current best if((v)>maxV) //reset all our variables that keep track of the best option fl oat d = toV.mag(); toV.mult(1/d); toBest = toV; maxV = v; } }}}} //only effect if fi nding something above a tolerance if(maxV>1){ applyForce(toBest); } } 40.

Stigmergy processing code snippet

The raw code to the left, describes the key function that drives the Stigmergy behaviour.

(A)

It took a while for me to fi gure out how this was actually working. I had to read through and annotate step by step in order to decipher the code. Importantly, this code creates the opportunity to link in more variables. As what is seen in latter images incorporates multiple fi xed values that can be made into dynamic values. In later sketches I will add oscillation and probability to vary the angle of vision, the tolerance and the search radius. Manipulating these variables should allow for signifi cant change in the outcome.

(B)

(A) Agent’s local neighbourhood in which it reacts (B) Field of view and structure of weave when search radius is 1.

37-40. See Stig_3, Key part of code that directs the acceleration of particles 53

41. export

Stigmergy processing image (A)

A search radius of one causes rivulets to develop. Adding the function of mouseDragged() for spawn locations, accelerates experimentation with this parameter.

42.

44.

43.

45.

(A)

46. export

Oscillation added to Angle of Vision (Field of View) Increased Clustering or ponding.

Stigmergy processing image

41-46. See Stig_3, Close up images of Stigmergy sketch 42, Screen shots at progressive frames of the same sketch 55

(A)

Spawning multiple agents in the same position causes this linear, zig-zag behaviour. The agents field of view causes it to weave back upon the initial straight lines. This acts more like a qualitative trigger, as the field of view function is triggered by the environmental structure.

(B)

As time progresses the agent fills in the spaces between the pathways. This explore, then weave, then fill behaviour is emergent, and will be interesting to explore further.

47.

Stigmergy processing image export 48.

47. See Stig_directed1, my Processing sketch - frame 200 48. “ “ - frame 1050 -. “ “ - frame 1600

(C) As the sketch progresses, top left to bottom right grains may occur as a result of the pixel worlds origin being in the top left hand corner, either the velocity range did not include negative numbers. 56

II.1.5. Stigmergy 1. //RAW CODE class Creator { PVector loc; PVector vel; PVector acc; fl oat maxvel; int count =0;

(A)

Creator (PVector _loc, PVector _vel, fl oat _maxvel) { loc = _loc; vel = _vel; maxvel = _maxvel; }

Also, it was learnâ&#x20AC;&#x2122;t that the stigmergy process in general is resource heavy, and runs slowly on the system even without the extra mover system layer. An optimisation process for sidestepping this issue is as yet unknown to me.

void run() { display(); update(); spawn(); checkEdges(); } void display() { noStroke(); fi ll(100); ellipse(loc.x, loc.y, 100, 100); } void update () { acc = new PVector (random(5,5),random(-5,5)); vel.add(acc); loc.add(vel); vel.limit(maxvel); acc.mult(0); } // add new moversystem in each frame as spawn // ing agent moves void spawn () { msystems.add(new moversystem(numMovers, new PVector(loc.x, loc.y), new PVector(random(-maxSpeed, maxSpeed), random(-maxSpeed, maxSpeed)))); } 49.

It was not until later stages of this studio that I fully grasped the computational limitation of processing as a program. Using a mover-system in this way suck up processing power by adding to many arraylists. Also, this extra layer is a needless complexity.

(A) Class for containing a population of stigmergy agents, to automate the spawning behaviour (B) Code that instantiates a new set of mover agents, and adds them to the sytemâ&#x20AC;&#x2122;s arraylist (constainer)

(B)

Stigmergy Mover System Code snippet 57

Stigmergy

II.1.5.

Added spawning Agent The aim of this sketch was to add a spawning agent to automate the distribution of stigmergy systems. The code from the previous page describes the introduction of the spawning agent. The crucial code section is the void spawn function which has a constructor which allows for variance in number of movers spawned and random velocity. The spawning agent was set on random trajectories. In the future I would like the spawning agent to follow some kind of intelligent pathway. For example, it moves towards a clear zone which has not been traced by the stigmergy system. This would allow development of a constantly spreading system. Jose Sanchez in his Open Processing Libary for the Stigmergy 2D sketch, pointed to the key point that the agents need to have some purpose 1. Just like termites the paths formed need to be fi nding out something. I need to think of what the stigmergy system could optimise.

(

B 50.

Stigmergy processing image export

51.

Stigmergy processing image export

In future iterations I would like to add a variable for controlling when and how many movers are added to each spawning of a mover system. 1 Jose Sanchez, Stigmergy 2D, (Open Processing), <http://www.openprocessing.org/ sketch/21385> [Accessed Sept 2012]

(A) Multiple Agent particle systems spawn-

ing from, a moving spawning agent.

(B) Clustering exhibited as multiple mov-

er-systems relatively on top of each other

52.

Stigmergy processing image export

(C)

53.

Stigmergy processing image export

Stimuli intensities,structure and agent behaviours need to be in balance with the environmental context. Environmental feedback loops must be made visible.

(A)

Spawning agent added to Stigmergy System

(B)

Equilibrium overtaken by rampant particle system spawning

(C)

Increased environmental fadeno significant results

(D)

Added oscillation to death speed -no significant results 59

A B

54.

Stigmergy processing image export

An unbalanced equilibrium can produce more interesting results as well.

(A)

Increased oscillation max for death speed

(B)

Increased background fade = equilbrium of white fill

B A

55.

Stigmergy processing image export

(A)

Increased spawn numbers

(B)

Emergent straight lines, agents inhibit each other

B C

56.

Stigmergy processing image export

A. Straight

(A)

lines emerge in parallel to grain

(B)

Increased numbers, fade an death

(C)

Consistent grain from top left to bottom - resultant of uneven instantiation?

B. oscillation C.

Curation: Adjusting settings with a graphical user interface

57.

By experimenting with the death speed of the particles and the fade speed of the background environment I attempted to fi nd an equilibrium of growth. This hopefully would allow an emergent form to develop.

Stigmergy processing image export

The fi gures 1 to 3, show a behavioural change in the particles as there search radius is increased. Figure 4 on the next page shows an instance when the search radius has been signifi cantly increased, in the context of the sketch parameters. The Graphical User Controls (GUI), see in fi gure 5, allowed me to introduce parametricism, with the aim of fi nding emergence behaviour from certain settings.

This manual control allows for a curation of the process to occur. In order to fi nd a sketch that exhibits behaviours of natural- systems the user has to experiment with the variables. 58. Stigmergy processing image export (A) I found it interesting to play with the fi eld of view (FOV) function informing the particles vector. Infl uencing FOV allowed weak control over the clustering and expansion of the particles. B.

For lack of coded genetic adaptation, human evaluated criteria is important to facilitate interesting and emergent outcomes.

I started to add oscillation effects to the acceleration in order to vary the movement. 56-59. See Stig_directed_12, Stigmergy sketch with mouseDragged Spawn

A B

59.

Stigmergy processing image export

Natural Systems look organic as there is more variance in behaviour, resulting in normalised curved patterns.

(A)

Stigmergy with increased search radius

(B)

Looks more like actual termite paths

Adding Physics to the Stigmergy Sketch

//RAW CODE

void searchAgents() { // need to fi nd out how to access arraylist in (A) //the moversystem //loop through all movers in arraylist for (Mover a: pop) { //get essential variables //if distance between one particle and an //other is //less than set variable // then apply repel force which is the //inverse of //applyforce function. //test agents locations to one another PVector diff = .distanceTo(a.location); if (diff > 0 && diff < 2) { //if with distance apply negative force //- repulsion PVector f = new PVector dom(5),random(5)); f.mult(-1); acceleration.add(f); }}}} 60.

Stigmergy mover system code snippet 2

//RAW CODE

void searchAgents(){ //reset accel for (Agent a:agentPop){ //get essential variables Vec2D diff = a.getPreviousPosition(). sub(this); fl oat d = diff.magnitude(); if(d<100&&d>0){ attract(diff.copy(),d); //attract to neighbour align(a.getVelocity(),d); //align with neighbour if(d<20) { repel(diff.copy(),d); //avoid neighbour }}}} 61.

Stigmergy mover system code snippet 3

(A) At this time I faced some structural issues with the code, In particular converting between PVector and Vec3D, inheritance, and general sketch structure.

In the following sketches I need to clarify how you can refer to arraylists inside a meta-particle system from inside a class. The problem came from trying to reverse engineer. The simplicity of the code was compromised and I will need to look at my structures in the future. Particularly, I will need to implement inheritance in more instances to modularise and simplify my code and input new behaviours.

The code refered to in fi gure 1 was aimed at searching through all the agents in the agent system, then to register distance between agents, and apply a repulsion force. I had problems patching together the extended particle example provided by Gwyllim Jahn, and my multi - particle Stigmergy system. I learnâ&#x20AC;&#x2122;t the importance of defi ning the code structure, ie extending the verlet Particle function from the beginning of the sketch. In the future when I see the need for physics at the start, I will build off a base class of the extended Verlet Particle. Although, I realised too late that it is far simpler to just add repulsion as another custom force. I began trying to implement an inverse of the acceleration, as seen in fi gure 1.

57. See Stig_ 9, Code snippet from Sitgmergy Sketch 58. Code snippet from Gwyllim Jahnâ&#x20AC;&#x2122;s, extended particle example. 65

Stigmergy Research

How could this idea of interactive memory sites be used in the architectural fi eld using humans as the agents of the stigmergic system?

Lim also states an important intellectual facet of stigmergic systems; “[p]roblem-solving information is actually embedded in the external environment as a form of external memory”. The idea of embedding memory into the environment through architecture and techniques derived from natural systems is very interesting.

Lim includes in his article a defi ntion by Zoologist Pierre Paul Grasse of a stigmergic system; “Stigmergy describes a form of indirect coordination between organisms using signals left in their environment. These signals persist and cue subsequent behaviours in other individuals”. Jason Lim in Proceedings from ACADIA 2011, explores the use of Stigmergy to derive the most optimum acoustic design for an auditorium. The key facet describes is the ability of the ‘rays’ or agents to change the environment they come into contact with1. The computer simulation done in Rhino and Grasshopper trys to emulate and prove the analog form fi nding used by Alvar Aalto at the Viipuri library in Vyborg Russia. See fi gure 1 for the Viipuri Library. The system designed emitted particles symbolising sound from a central point on the stage of a 3d modelled auditorium. The particles interacted with the auditorium structure and the seats. The interaction between particles and the environment were mapped and fed back into the environment.

62.

Viipuri Library Alva Aalto

Fig 1. Alvar Aalto, Aalto_viipuri_07, (USA, Souther Polytechnic State University), http://fac-web.spsu.edu/architecture/classes/ Setiawan/libraries/Aalto_libraries/ [Accessed Sept 2012] 66

Via multiple iterations and using pre conceived acoustic parameters an optimised acoustic space emerged from the stigmergic system. This non linear form fi nding approach proved the validity of Aalto’s analog procedure and the viability of the digital tool. 1 Jason Lim, 2011, Let’s Work Together: A Stigmergic Approach to Acoustic Design, In Integration Through Computation, ETH Zurich, Aterlier Panda, ACADIA 2011 Proceedings, 396

Volumetric Space Arrays and Toxiclibs

Why use VSAâ&#x20AC;&#x2122;s? A method to implement 3D stigmergy

//PSEUDO CODE Global Variables -Volumetric Space Array (VSA)

In order to create a 3D stigmergic sketch the program needs to be able to identify Voxels which are points with a resolution at each position in 3 dimensional space. As opposed to the 2D representation of 3D space which would not allow for 3D interaction to occur. 63. Volumet- 64. ric Space array pseudo code

Stigmergy Thematic image

Setup -Initialise VSA & Brushes, -Load Array, run voxelMesh function Draw -Draw bounding box, -run VSA function, -run agent functions Class Agent -Agent searches space then moves towards voxel with highest opacity, else, it moves randomly. -Agent stays within box. -Agent has chance of self-replicating -Agent path is traced onto world with brush func.

Class VSA -3D space is filled with voxels at x,y, z locations -func. for getting voxel resolution at each location - 3D space is filled with points at x,y, z locations with opacity constrained to range 0-255

60. Extrapolated from Monash University student, Jacksonâ&#x20AC;&#x2122;s VSA Sketch (Student at Monash Uni) 61. Thematic image which struck in my imagination the idea that not only entire structures could be grown using stigmergy, but it could also be used to organically deconstruct the existing urban context. Source: Retrieved from: http://farm1. static.fl ickr.com/118/308046510_ eb0a1948eb.jpg 67

3D stigmergy, and fl ocking AIMS -Add -Add -Add -Add -Use

Vec3D to Stigmergy Sketch Flocking Behaviours Physics 3D environment Voxel 3D Stigmergy Sketch

Agents following the most used path left by traces of previous agent movement, whilst acting according to fl ocking behaviours. Trying to re-create in essence the forms emergent from the stigmergic behaviour of termites. However, termites follow different and more complex processes. This sketch only takes into account the path following behaviour of termites.

//PSEUDO CODE Global Variables

66.

-ArrayList flock Setup -Initialise ArrayList

65.

Termite Hills, Stigmergy Thematic

62. Thematic image. Termite Mounds, http://www.ourterritory.com/katherine_reRetrieved from: gion/images/termite_hill. jpg 63. Pseudo Code summarising raw coded extension of an extrapolated VSA Sketch, plus add Shiffmanâ&#x20AC;&#x2122;s 3D fl ocking example. Courtesy of Jackson from Monash University and Gwyllim Jahn 3. Next Page. Image from VSA sketch incorporating fl ocking. Flocking seems to be preventing stigmergic behavior in this version. World borders can be clearly seen where the white volumetric arms change angle (bounce off world edges). This image for noise than a coherent system.

Draw -Create ArrayList -run agents through ArrayList Class Agent -Agents run through ArrayList -Agents follow best path -Agents trace paths -Agents have cohesion -Agents have separation -Agents have alignment

67.

3D stigmergy processing image export

67. .volumetricspacearray_ext_fl ocking(frame 1681) _Extends G,Jahns Sketch 69

3D stigmergy, and fl ocking

68.

3D stigmergy with fl ocking, processing image export

69.

69-72 .volumetricspacearray_ ext_fl ocking(frame 1681) _Extends G,Jahns Sketch

70.

71.

(A) Flock of agents each with a small brush which leaves a trace on the VSA environment. 3D pathways emerge. (B) Straight branching structures emerge because the search radius has been reduced to 1. This makes the agents want to zig-zag. (C) As a result of experimentation it is apparent the fl ocking behaviour counteracts with the stigmergic behaviour resulting in noise.

72. 3D stigmergy with flocking, processing image export 71

3D stigmergy, and fl ocking

Flocking behaviour leads to more intense pathways, and it could be argued represents a more reactive and realistic stigmergy. This is because fl ocking strengthens the initial creation of stigmergic pathways via applying more agents to the task. Flocking also enables a heightened sensitivity to a pathway, as more agents are within range of each search zone.

73. 3D stigmergy with fl ocking close up, processing image export

Flocking adds anther layer of complexity which pushes the outcome beyond the initial range of our imaginations. I have imagined that a VSA stigmergic system could act as the environmental stimuli, shaping another trace within the space. For example, the negative space defi ned by the stigmergy could be extrapolated as the architectural space, and then further manipulated by agents systems. A stigmergy system could apply force to a force directed network, or even act in concert with a cellular automata structure.

74.

Stigmergy Thematic

(A)

The large black dots (Agents) are more likely to follow the white dots (Voxels), the agents leave behind more white, this leads to stigmergic patterns, and emergent pathways.

(B)

Agents also want to fl ock together and form a group.

70. volumetricspacearray_ext_ fl ocking(frame 1129) 71. Thematic image that suggests â&#x20AC;&#x2DC;noiseâ&#x20AC;&#x2122;, or random progression of stigmergic behaviour (out of control behaviour) can still be viable as an aesthetic product. As the stigmergy retains as sense of incoherence when the logic is not applied to some architectural fi tness measure. Source: Suttle, D, Engel, D. so SUGITA, stickMergyUniversity of Pennsylvania, retrieved from : http://www.suckerpunchdaily. com/?s=STIGMERGY

75. Non -Linear Research Facility, using Stigmergy

How to extend 3D stigmergy? How to apply this process to an architectural application? Roland Snooks and his architectural firm Kokkugia provides a example for how these systems can be used in practice, typically used in design competitions. Source: http://www.kokkugia.com/ 72. Chun, K H. Ettinger, D, Song-Ching T, D. Center for Non Linear research Philadelphia Pennsylvani, Retrieved from: http://www. suckerpunchdaily.com/2010/01/17/center-for-non-linearresearch/#more-5094 73

Fractals II.1.7.

76.

Michael Hansmeyer Fractals Thematic 75

Fractal Generator

77. Fractal Generator - from Open processing

//PSEUDO CODE

78.

(A) Structural Logic emerges from recursion technique. Also describes a method of fi lling space with a connected network.

Global Variables -ArrayList of Fractals, ie Branches

(B) Since, the Stigmergy exploration I have been interested in the space created between the growth structures, this is an opportunity for describing architectural space

Setup -Initialise ArrayList -Add Fractal structure

Recursion is a powerful tool, however, it has limitations in regard to accessing the growth nodes and manipulating the growth process.

Draw -Build in generator, which resets ArrayList, creates new fractal Class Fractal -Create for variables - Branch size - Limit to recursion (Stops infinite loop) -rotation of growth direction -growth length in new direction -fractal grows one, step, growth instruction is called within itself -cont. till limit 76

79. Code

Fractals Pseudo

78 & 79) Fractal structure generated using sketch, extrapolated from Henderson (User) http://www.openprocessing.org/user/3583 http://www.openprocessing.org/sketch/6830

L-systems

L-Systemâ&#x20AC;&#x2122;s seem to have more fl exibility than a recursive fractal, when used as a dynamic platform for organising a structural growth. 82. L-System Pseudo Code

B A

81. L-system processing image export (A) Agents located by growth instructions setup via a string or characters, that encode for more elaborate instructions. (B) As recursive functions not used, Agents can be accessed for future actions. (C) Environmental factors can feed back into

the text defi ning the growth behaviour, this will require more knowledge surrounding the grammar structure of L-systems and exploration into adaptation.

//PSEUDO CODE Global Variables -ArrayList for Agents -ArrayList for Points -Growth Variables -String Production constants How growth instructions are read -Declare L-system library utitlity Grammar Setup -Init & Setup Grammar -DNA or growth instructions as a text Draw -Init Agents to hold points in L-system -Run Physics world -Read through growth instructions and create locations for agents to populate from this text Class Agent -Extends VerletParticle, useful for later use. -draw agent as point -base structure for future agent behaviours

80. A thematic example of the potential of L-systems. Source: http://www.michael-hansmeyer.

com/fl ash/l-systems.html

Force Directed Networks With Swarming Agents - Autonomous Agents II.1.6.

83.

Force Directed Network Thematic

Combining Systems in order to achieve architectural outcomes, and complex systems Why use Force Directed Networks? “ [F]orce directed graphs [or networks] have provided a means of organising relationships and rationalising them within cartesian space. “ Also, using Isosurfaces, (a method of applying a skin to a dynamic structure) we can “...create surfaces in-situ within a particle context with a high degree of control and fl exibility.” In this way complex, dynamic data can be organised and distributed in space to inform the construction of architectural space and structure. 1 1 Collins, M., & Hasegawa, T. (2009). Deriving Architectural Surfaces from Relationship Graphs. Retrieved from Proxyarch website: www. proxyarch.com/PDF/DerivingSurfaceFromGraphs.

84. ‘Onion Skin’ building diagram using graphed form thresholds 84. An example of a force-directed, edge bundling graph for visualization of complex data set. This has architectural potential for organising space and parameter sets. Source: http://www.vizworld.com/2009/06/

force-directed-edge-bundling-for-graphvisualization/

85. Onion Skin facade, using multiple thresholds of a graph to drive surface form generation, from Figure 8, in (Collins,Hasegawa,2009)

Force Directed Networks With Swarming Agents //AIMS Create a base Fractal tree or L-system Create an agent system over this Add Springs, make a force directed network (FDN) Add Physics, friction, gravity ? Swarm agents sculpt the FDN Introduce Mesh Agents, or Marching Cubes

Ideas: Force Directed networks can act as the base structural and organisational logic for an architectural system. Overlayed swarm agents can manipulate the structure, based on tendencies introduced into the sketch. Mesh Agents can be added to cloth the architectural construction. 86. An example of edge bundling used in a force directed map. 2010, Retrieved From: http://boyandi.net/assets/works/images/ bundling/us-migrants-complexity-bundled. png 85. Edge Bundling & Spring Network Graph example

My evolving concept idea is leading down the line of adapting and combining a swarm system, with a base environmental mapper (ie L-system) and fi nally, with a meshing agent system. L-systems seem to be a fruitful path to explore as the DNA like instructions used to generate a map of particles, provides a platform for encoding and adaptive system. For example, the L-system instruction grammar is adapted in response to the environment or swarm agents. Fractals and L-systems represent the natural process of a living structure growing in an environment. This provides an opportunity to use these systems to organise architecture in a metabolistic fashion. The Architecture grows in the urban realm according to the resources and opportunities of the space. Fractals are also inherently structural as they are based on recursion, which can generate symmetrical self -similar structures. Self-similar base logic for architecture is also useful for simplifying fabrication, and preserving resources.

Force Directed Networks With Swarming Agents

86.

Force Directed Network processing image export

3D network of nodes create a base structural logic. System held together by spring physics and selfrepulsion between nodes. Swarm agents trigger behaviours in network.

(A) Springs between network, organised by closest point. (B) Swarm agents, exhibiting Craig Reynoldâ&#x20AC;&#x2122;s steering behaviours. Problem occurring with clustering and not effecting network properly.

//PSEUDO CODE Global Variables -Declare L-system variables -Declare swarm agent variables

Setup -Initialise physics -Setup L-system grammar -Add initial swarm agents Draw -Update physics world -build L-system -add L-system points to arraylist -attach agents to L-system points -set switch cases

See l_system_swarm5 sketch

Class Agent -Extends VerletParticle -Searches for closest neighbour -searches for other sAgents in nearby -searches its own system arraylist -updates position (moves) Class sAgent -Flocking agent -Flocking behaviours -cohesion -separtion -alignment -go to random Agent position -triggers Agent behaviour -Future- build in path following

Self - Organising Networks

(A) Boxes are pulled together by spring physics implemented with the toxiclibs library. (B) Nodes eventually stack themselves into two groups, separated by the fl ocking swarm agents

87. Spring Stacking Boxes 88. Force Directed Network processing image export 89.

88-90. Frame progressing with time,See Lsystem_swarm5 sketch

Force Directed Networks With Swarming Agents

90. Force Directed Spring Network Processing Image export

91. Force Directed Spring Network, close up Processing Image export 82

3D path following - need to predict future path

A (A) Spline3D (from toxiclibs) run

through points imported from the L-System sketch

(B) Agents use Craig Reynoldâ&#x20AC;&#x2122;s path

following algorithm. Implemented with PVector.

92. 3D path following processing image export 1

//PSEUDO CODE

Global Variables -Declare Arraylist to hold imported points -List for Spline3D -Declare path object -ArrayList for Agents Setup -Convert points to spline3D -3D camera setup -Call function to create new path -Add initial agents to world

93. 3D path following processing image export 2

Draw -display spline3D path -loop through agents and run functions -custom functions -create new path -add boid

Class Agent -Declare Properties for movement -Constructor - control location, maxforce and max speed -apply force to follow path -follow path function -predict future direction -find normal target on segment of path ahead -check how far away from path -Agent separation function -Agent steer

94. 3D path following pseudo code

Class Path -Init arraylist to hold points of path -radius of path - function to add points to path -display path 83

Concept Evolution

AIMS: Reconfi gure PVector path follow to Vec3D Thread agent paths through FDN Path through network is dynamic FDN nodes lock when a certain condition is met Nodes change characteristic dependent on organisation Use a version of cellular automata for internodal commâ&#x20AC;&#x2122;s Learn about adaption and implement Apply mesh agents to skin the structure For my fi nal project I am interested in implementing a multilayered complex systems incorporating, l-systems, force-directed networks, agent swarms, cellular automata and stigmergy. Via layering these different tools complex emergent behaviour and patterns can be massaged out of the code.

The idea is to create a base structural logic that reacts adaptatively to the metabolism of the local environment. This base structure is populated with agents nodes that are attached to the structure. The nodes react with each other to self-organise. Agent swarms following paths, using either 3D path following or stigmergy, trigger node behaviours. The nodes and base structure gradually shape into a form in equilibrium. Mesh agents trace the base structure and create a skin or internal network lattice. 3D print the structure.

PVector to Vec3D issues

Issues converting PVector to Vec3D and making the 3D path following algorithm work with my force directed network and swarms

A Vec3D as a tool for describing 3D space has more functions and utility allowing more complicated sketches

95. 3D path following close up, processing image export 3

//RAW CODE

// A function to get the normal point from a //point (p) to a line segment (a-b) // This function could be optimized to make fewer //new Vector objects Vec3D getNormalPoint(Vec3D p, Vec3D a, Vec3D b) { // Vector from a to p Vec3D ap = p.subSelf(a); // Vector from a to b Vec3D ab = b.subSelf(a); ab.normalize(); // Normalize the line // Project vector â&#x20AC;&#x153;diffâ&#x20AC;? onto line by using the //dot product ab.scaleSelf(ap.dot(ab)); //COULD BE THIS (B)

}

Vec3D normalPoint = a.addSelf(ab); return normalPoint; 96. 3D path following code snippet

(A) Path points are nucleated into one point. Path is not shown. (B) Problem is in the agent class

Cellular Automata II.2.6. The cellular automata problematic

System can be beyond prediction Failure of prior models

Simulation

Test utitlity

Planning Tools Economics Link external factors

San Franciso Bay Area

Weather Topography

urban Growth

Multiple Datasources

Road Networks

Check overall growth

Existing Settlements

Cellular Automata Diffusion

Change over time

97. Cellular Automata problematic diagram

Breed Rules

Spread Slope Resistance Road Gravity

Control Parameters

Self - Modify

Adapts to circumstances it creates

Accumulates probalistic estimates

Future Scenario Generation

Probabilities

? Analysis

Monte Carlo Version of the model

Build - using CA model

Future Risks

GUI Interface User interactivity Optimise Results

Future opportunities

Genetic Algorithm

Future Applications

Use Neural Networks

//based on Clarke and Hoppen

Test for fi tness

CA rules - learn over time

II.2.6. Cellular Automata

CA have been widely used in the modelling of urban growth for multiple reasons: •”They are inherently spatial; their defi nition on a raster of cells, and on neighbouring relationships are crucial; •They are simple and computationally effi cient; •They are process models that deal with state changes; •They are dynamic and can then represent a wide range of situations and processes”1. 1 Diappi, L., Bolchim, P., & Buscema, M. (2005). Improved understanding of urban sprawl using neural networks. Recent Advances in Design and Decision Support Systems in Architecture and Urban Planning, 33-49.

98.

Marc Fornes Cellular Automata thematic images

Cellular Automata II.2.6.

99. PSEUDO CODE ANALYSIS LOOP //Collect historical data //Map Historical data //create grids to define environment, defines growth modules //create ‘seed’ cells, located upon historical distribution patterns //define local behaviour rules //Historical Analysis cont. //Analyse random cells //look for discrete spatial properties // is it urban? // slope ? // close to infrastructure? //[urbanising cell] //neighbourhood behaviour weighted by set of probabilities GENERATIVE LOOP //run generative CA - based on found rules //Apply Change Rules //Diffusion //Breed //Spread //Slope - Resistance //Road Gravity //Apply Self Modification Rules //Compute & Save Descriptive stats //test entire generative loop against rules defined by ‘pseudo random” numbers

100. Cellular Automata, San Francisco simulation rule diagrams

II.2.6. Cellular Automata

Global Variables 102.

Cellular Automata thematic images

//RAW CODE

void memState() {

Setup

tendency=0; frames ++; if ((onCount - offCount) > 1 ) { defState = 1; onState = true; } else { defState = 0; onState = false;} fl oat stateDif = abs(onCount - offCount); fl oat change = stateDif / frames;

(A)

//chance of returning to default state int rnd2 = int (random(100));

onCount = 0; offCount = 0; frames = 100 - phaseChange;

Class CA

constrain(change,0,1); fl oat phaseFactor = (stateDif * 100) - phaseChange;

}

if (rnd2 < phaseFactor) { futType = defState;

constrain(tendency,0,100); if(rnd2 < tendency) { futType = 1; }

-Initialise grid of new CA objects using custom class. -Loop through 3D array and create location points at each array node for placing CA object

Draw -Loop through array and run CA functions; run and update type separately.

if( stateDif > frames) {

}

-Declare neighbourhood variables -Declare 3D array

(B)

-Create x,y,z integer variables -create type and future type variable. -function to evaluate neighbour - test if automata around this object is on or off. -Count how many are on & off. -this count effect custom rules for this object future type. -update type with future type (A)

101. Cellular //introduce some chaos Automata processint rnd3 = int (random(100)); ing code snippet if( rnd3 < 1) { 103. futType = otherState; code if(onState = true) { onCount -= fl oor (onCount * .05); (C) }}}

Cellular Automata pseudo

Cellular Automata II.2.6.

104. port

Cellular Automata processing image ex-

(A) Previous Page- Based on Jose Sanchezâ&#x20AC;&#x2122;s 2D cellular automata tutorial. Added memory to the system. CA counts off and on states and determines the most common state. (B) Previous Page- Attempted to add a tendency to become a certain future type based on another set of rules. (C) Added a random chance of changing to the opposite state, this functioned as a type of erosion.

105. port

Cellular Automata processing image ex-

Genetic Algorithms II.1.8.

Genetic algorithms sprung from John Holland and colleagues’ initial research into Cellular automata. John Holland termed the phrase in 1975, did not get going as a fi eld until the 1980’s, as required a advances in computing power. Not shape grammar - GA- stochastic selections based on fi tness measures - multiple individuals. Shape grammar - deterministic GA - generative There are multitudes of different types of GA’s and methods of implementing them. “One of the distinctive features of the GA approach is to allow the separation of the representation of the problem from the actual variables in which it was originally formulated.” (Reeves, 2003) (Flake, 1998,p337) “Thus, adaptation can be seen as a computation of the most complex form that emerges through the multiplicity and recursion of simple subunits.” 1960’s John Holland – championed idea of the genetic algorithm Gregor Mendel – “traits are inherited in discrete chunks of information”(Schema) – solved incompleteness of Darwinism – neo Darwinism – heredity. Information as code invertible to needed information – GA can be applied to algorithm. Include (Flake,1998,p344) Simplifi ed genetic algorithm • Initialise the population, P • Repeat for some length of time: • Create an empty population,P’ • Repeat until P’ is full: • Select two individuals from P based on some fi tness criterion • Optionally mate, and replace with the offspring • Optionally mutate the individuals • Add the two individuals to P’ • Let P now be equal to P’

THE GA RECIPE Define Fitness Functions

Define Genome Logic

Randomly Generate Initial population of genomes

Test fitness of designs generated from each genome

Identify top performers, make them the selection pool for next generation cloning Using selection pool from last population, create new generation, use methods of cloning, cross-breeding, and migration

Cross-breeding Mutation Migration

Test all genomes in the new population

Optimal Solution Test for convergence Repeat breeding

106. gram

The genetic algorithm recipe dia-

II.1.8. Genetic Algorithms

Natural systems provide a model for breaking open formalised problems and assumptions via basing analysis on the local variables and interacting subcomponents rather than the meta representation of the system.

Combining GA’s with objective rule generated forms

Parametricism Alone

Combine rules and parametricism = richer design outcomes

Its possible to use objective rules to guide and generate urban fabrics

and “implicit parallelism” - (IP questioned “In fact, intrinsic parallelism turns out to be of strictly limited application; it merely describes the number of schemata that are likely to be present in some numbers given certain assumptions about string length, population size and (most importantly) the way in which the population has been generated—and the last assumption is unlikely to be true except at a very early stage of the search.”

Combine GA’s with designer intervention

Black Box Algorithms

Parametric Algorithms

107. Genetic Algorithms and parametric rules diagram

1960’s - operational research (OR) - Heuristics - neighbourhood search - combinatorial optimisation problems. “The basic idea is to explore ‘neighbours’ of an existing solution—these being defi ned as solutions obtainable by a specifi ed operation on the base solution.” (Reeves, 2003) “DeJong’s work established that population-based GAs using crossover and mutation operators could successfully deal with optimization problems of several different types, and in the years since this work was published, the application of GAs to COPs has grown almost exponentially.”(Reeves, 2003) GA’s can also be used for unknown solutions, by acting on neighbourhood “attributes or other indirect characteristics”, to create a pattern based on a desired principal rather than a fi xed outcome”(Narahara, Terzidis 93

Genetic Algorithms II.1.8.

Fitness Agent

Pseudo code

Genome component

//generate a 4 grids of squares spaced evenly across a 2D bounded environment //each grid of squares is considered a singular genome //spawn 1 Fitness Agent in the centre of each grid, 4 in total within the environment //the Fitness agents have random velocities and a constant acceleration //if the agent hits the environment boundaries it is respawned in the centre of the world(for fairness). //each grid of squares counts the number of collisions by an agent with itself //average the number of collisions //Arbitrarily set a generation time as a number of frames - say 1000

109.

Concept Diagram 1

world boundary

//average the collisions counted by each grid //The fitness is determined by the highest recorded average number of collisions. The fitness tests for the ability of a grid to contain agents within its bounds //out of the four grids, the best performing grid is used to populate the next generation //in the new population a random selection of squares within each grid is selected to rotate by a random degree on its axis, this happens only once each generation //the best collision count is displayed as text on the screen of the program

108. 94

Evolving Grid processing image export

II.1.8. Genetic Algorithms Pseudo code //generate 4 polygons spaced evenly across a 2D bounded environment Fitness Agent

//each polygon genome

Genome component

is considered a singular

//populate the edges of the polygon with vertices which will act as sensors, detecting agent collisions. (use toxiclibs 2D & .contains() function to determine collisions) //spawn 4 Fitness Agents randomly within the environment

world boundary

//the Fitness agents have random velocities and a constant acceleration //if the agent hits the environment boundaries it is deflected, inverse velocity. //each polygon counts the number of collisions by an agent with itself //compare the number of collisions with the other polygons, determine highest count, this will be the fittest organism. The fitness tests is for the ability of a polygon to retain agents within its neighbour space. //Arbitrarily set a generation time as a number of frames - say 1000 //out of the four polygons, the best performing grid is used to populate the next generation

Future Tweaks //step through generations until interesting shapes emerge //add user interface to control mutation scale, and population sizes of agents and polygons

110.

Concept Diagrams 2

//incorporate location of polygon, taken from its centroid as ain heritable trait. // add negative fitness factor, increased size of polygon acts against fitness

113.

Evolving Grids procesing image exports

111.

112.

114.

118.

115.

119.

116.

117.

Genetic Algorithms II.1.8. 120. The genetic algorithm problematic

THE GA Problematic

Utility? Now

Application?

Interesting? Future Problematic?

Capacity? Possible Additives

Computation Production time frame?

Get more complexity from a simpler genome

Layering the Genome, Example DNA & RNA, Coded ExamplePhenotype lookup tables or Directed Graphs

Concurrent Adaption within the computation cycle

Size of population?

Length of Genome Sting?

Logic of Genome characters, interpretation into design phenotypes?

Definition? Fitness? Measured?

Mix GA with Swarm optimisation or other technique

Sample genome diversity, before optimisation of singular genome neighbourhoods

How to solve multi - objective scenarios?

Weighting of fitness components?

How to select, genome for next generation?

Definition? What and when is convergence?

Designer intervenes in the GA process, Interactive subject ivity

Detected?

Utility? Now Application?

Interesting? Future Problematic?

II.1.8. Genetic Algorithms Future Code Extending the Genetic algorithms presented earlier, this method has pontential for use in urban modelling. Taking the work done by Marshall 2005 and Celani et al, 2011 as a basis, we can implement the use of multi agent systems and genetic algorithms to find adpative urban forms.

thematic images

http://emtech.aaschool.ac.uk/ann ouncements/

The task would be similar to the research stated above by incorporaing the â&#x20AC;&#x153;characteristic urban grammarâ&#x20AC;? into the fitness evaluation parameters of the agent system. To elaborate we could begin to define the space of a characteristic urban grammar as the time it takes between agents colliding with objects. This translates the spatial syntax of the formal shape grammar into a particle ray system. Space defined by rays projected into space, and the time it takes to travel between objects.

http://www.designemergente.org/

The structure of space is defined by fitness ratios calculated from look up tables that transcribe ray collision times with an urban form. The problematic here is that the ray collision counts may not be able to accurately describe a desired space. There would need to be a secondary interpolation of ray collision counts to decipher its spatial description.

Ray Traced

Triangulation of multiple, ray collision events may be needed to map the fitness unit of the forms being tested.

121.

Future Genetric algorithm concept diagrams

Concept images

May need to use this process to map existing urban forms in order to get data, and translate it into corresponding triangulated ray steps. Good urban models could be analysed using this ray method and used to generate design versions or to further analyse existing urban forms. 99

Genetic Algorithms II.1.8. Pseudo Code Fitness Agent

//Spawn fitness agent at random position

Fitness Agent path

//given agent random velocity

Genome component

//limit velocity to a constant //fill environment with genomes with polygon forms. //if an agent collides with a polygon its vector path reflected to the perpendicular //the polygons can evolve in shape. //the fitness criteria is dependant upon a series of triangulations, measured by time steps between agent collisions with the polygons.

Spawn point Life time = 0 Gen = 1

//time steps could be arbitrarily set at 9 collisions. After which the triangulation of the agent path is related to a look up table, determining the relative fitness of the agent movement in describing â&#x20AC;&#x2DC;goodâ&#x20AC;&#x2122; urban form. //time = 3 collisions, add length of each step between collisions. Store as part of a set of 3 values. //time = 9 collisions, add up all collisions lengths and compare to fitness table. //return value, intermediate fitness rating, add to total fitness value.

Life time = 3 collisions Gen = 1

//continue until life span time limit is met //evaluate overall performance of set of polygon genomes. //add fitness data and polygon configuration to memory //remove this configuration of polygons //repeat this entire process but but with random variations to the original polygon location and shape.

Life time = 9 collisions Gen = 1 122.

100

Genetic algorithm future concept cont.

//continue until we have sufficient population size to enact genetic cross over. //select fittest configurations and use to populate next generation //repeat individual and generational process, until interesting forms emerge

II.2.9. Neural Networks

101

Neural Networks II.2.9.

Artifi cial neural networks (ANN’s) “... are massively parallel computing systems consisting of an extremely large number of simple processors with many interconnections”1. ANN structure is made of a collection of “adaptive processing elements(nodes)” and a collection of “unidirectional data connections (weights)”2.ANN’s learn patterns by changing connections between nodes, and adapting synaptic weights, in order to organise the communication of signals through a network3. ANN’s are being researched and designed in order to mimic the self - organising biological neural networks (BNN) found in nature. The aim is to create artifi cial intelligence that can solve problems such as pattern recognition, prediction, optimisation, associative memory, and control4. ANN’s have many diverse uses for the architectural fi eld. Target characteristics of BNN’s which would be highly advantageous to artifi cial computing include; massive parallelism, distributed representation and computation, learning ability, generalisation ability, adaptivity, inherent contextual information processing, fault tolerance, and low energy consumption5.

1 Jain, A. K., Mao, J., & Mohiuddin, K. M. (1996). Artiﬁcial neural networks: A tutorial. IEEE computer, 29(3), 31-44. 2 Diappi, L., Bolchim, P., & Buscema, M. (2005). Improved understanding of urban sprawl using neural networks. Recent Advances in Design and Decision Support Systems in Architecture and Urban Planning, 33-49. 3 Flake, G. W. (1998). The computational beauty of nature [electronic resource] : computer explorations of fractals, chaos, complex systems, and adaptation / Gary William Flake: Cambridge, Mass : MIT Press, c1998. 4 Ibid 5 Ibid

102

ANN could have some of the following potential uses for architecture1: In Pattern recognition; - This subclass of ANN has great potential for architecture as the practice is based on pattern. An ANN could be used to read specifi c types of forms, material structures, agent and material dynamics, and informational patterns. Once a pattern is learn’t then it can be applied to an automation routine, reducing human labour and speeding up the analysis of problems. In Function Approximation; - When ANN’s are used in reverse patterns can be analyzed in great depth and used to decipher complex problems. Because when the output is known then the process can work backwards through the network to see what target weights are required for optimal function. In Signal Processing; -ANN are good at fi ltering out noise or competing inputs that do not fi t with the solidifying pattern. ANN’s provide vast potential for managing the increasing data load applied upon architectural projects. In Control Processors; -ANN’s can learn to duplicate another controller, ie a human. A pattern can be matched to a behavior set allowing previously “machine hard” tasks to be carried out by machines. 1 Flake, G. W. (1998). The computational beauty of nature [electronic resource] : computer explorations of fractals, chaos, complex systems, and adaptation / Gary William Flake: Cambridge, Mass : MIT Press, c1998.

II.2.9. Neural Networks

“Emergent techniques”, such as [ANN] have been used in spatial modelling of urban centres in the last decade of the 20th century1. Researchers from the School of Engineering at the University of Sao Paulo, have applied ANN to spatial interaction models of Brazillian municipalities, with the aim of modelling the allocation of health and education resources to the stocks and fl ows of the Brazillian populations2. This process is defi ned as a Neural Spatial Interaction Model(MSIM). The results of the MSIM were evaluated against “traditional gravity models”. Prior to this study it was generally held that ANN models had better performance than gravity ones. The performance of the MSIM and gravity models were judged on their ability to represent already known outcomes. The research fi nding found that the MSIM was only more effective in one specifi c case, in other instances the gravity models were better. The fi ndings of this research highlights that the accuracy of an ANN as previously stated is completely dependant on the data set inputted. Irregularities in the data sets, and extrinsic infl uences undermine the both the training of the network and the evaluation of the outcome. Further Research into the use of MSIM for urban planning may include improved strategies such as Genetic algorithms for shaping the network confi guration3.

1Akamine, A., & Silva, A. (2005). An evaluation of neural spatial interaction models based on a practical application. Recent Advances in Design and Decision Support Systems in Architecture and Urban Planning, 19-32. 2 Ibid 3 Ibid

Given the predominant use of Cellular Automata in modelling urban growth, neural networks have been looked at to add the ability to uncover the implicit rules activated across diverse spatial territories. Supervised neural networks have been used to model the spatial pattern of settlements and the phenomenon of urban sprawl1. One example is the modelling of urban growth in the south Metropolitan area of Milan by researchers from the Department of Architecture and planning in Milan. Their research methodology is to use “Neurocomputing” in a reversed, bottom-up approach, directed at “... discovering rules, relationships and scenarios from a database”2. Urban data from 1980 and 1994 to 2008 was used in a SOM(Self Organising Map) along side a ANN to identify “typologies of transformation”, this lead an understanding of “territorial morphologies”3. The limits of this approach is found in the supply of foundation data to feed the ANN, accuracy is gained from having a comprehensive data set to learn from. The research team found that their model provided “sound spatial logic for future trends in urbanisation” that would inform more fl uent planning decisions in the future”4. In particular the modelling of urban growth highlights the “urbanisation risk for unbuilt cells” which could be alleviated through density regulations5. 1 Diappi, L., Bolchim, P., & Buscema, M. (2005). Improved understanding of urban sprawl using neural networks. Recent Advances in Design and Decision Support Systems in Architecture and Urban Planning, 33-49. 2 Ibid 3 Ibid 4 Ibid,p47 5 Ibid, p48 103

Neural Networks II.2.9.

//Pseudo Code //used to create the Neural Network(Genetic Algorithm optimised) agent behaviour //Create an object called a critter that lives in a 2d environment //the critter lives within a population of other critters, and feeds on a population of food particles. //initially generate a set number of critters and food particles in the 2D world. //the critters searches for the closest food particles

The open processing example ‘Neural Network Critter’ by D.Ruckson was used as a starting point for learning the basics of ANN. This example uses a multi-layered perceptron/neural network and includes the use of a genetic algorithm for optimising its function.1

1 D.Ruckson, ‘Neural Network Critter’, Retrieved from: http://www.openprocessing.org/ sketch/65326

//the critters move towards the food particles based on the optimised velocities outputted from the Neural network. //evaluate how many food particles each critter eats per set cycle of frames. Average out this number and hold this variable as the fi tness threshold. //use the fi tness value to test the population of critters. //if population passes the fi tness test they are all mutated and passed through the evaluation cycle again.

123. Neural Network Critter processing image export, example from Open Processing

//add all fi t critters to an abstract population keeping track of all fi t parents. //Remove all critters if average fi tness falls below fi tness threshold. //reset the global population of critters using the genetic crossing of sets of two parents. //fi tness of the critter population gradually increases until it reaches an optimised result. //the critters become better at eating the food particles

104

124. Neural Network Critter processing image export, example from Open Processing 125. Code as seen from open processing, Evenly distributed food particles 126. Evenly distributed food particles

II.2.9. Neural Networks Food particles distributed too top left quadrant

A 125. Neural Network Critter processing image export, example from Open Processing

(A)

Critters stop moving when food is not close by

(A)

Critters lost in vacant space

126.

//Tweaks required //create variable for holding position of last food particle eaten.

127.

This sketch highlights the need to build in layers of behaviours that can deal with different environmental conditions. ANN should be balanced with in-built or hard coded redundancy measures, as the tweaks to the right would accomplish.

//add another time counter to the critters, if they have not eaten after a certain amount of time, then they should travel back to location where they last ate. //or add random velocity, that is activated when a food particle hasnâ&#x20AC;&#x2122;t been eaten in a long time

105

II.2.9. Neural Networks Cont.

128. 106

Image stack isosurfaced in Amira, using images from Neural Network Critter sketch

107

129. 108

Image stack isosurfaced in Amira, using images from Neural Network Critter sketch

130.

Volren in Amira, using images from Neural Network Critter sketch 109

Learning achievements III.1.

The most valuable result of this studio has been a complete reevaluation of my design process. This subject has forced me to reconsider the importance of suspending belief and pre-conveived ideas before any design investigations are started. Secondly, this Natural Systems Studio has inspired me to consider algorithmic thinking as fundamental to â&#x20AC;&#x2DC;goodâ&#x20AC;&#x2122; design. The ability to break a problem down into small parts with inter-related behaviours, from which simulated version can be selected is invaluable. Thirdly, I have achieved a moderate level of coding knowledge which has given me the key to further independent learning in this area. The most worthy result of this studio was ability to figure out how to code the subdividing spring network sketch. There are many floors in this sketch and yet, many barriers were passed which would of been inconceivable to pass fourteen weeks ago.

110

III.2. Future work I am extremely interesting in the approach of “proflifigate prototyping” inspired by the natural systems model, especially the genetic algorithm and its potential generative facilities. I will continue to learn scripting (coding) as a tool, because I now consider it a fundamental ability of the “hacker architect”. My future work will be informed by the ideas of navigating complexity via an algorithmic method, whilst maintaining a healthy scepticism, in order to sort noise from coherent results.

111

References IV. Figures

1. Thematic Image, SpaceSuit 3 2. Adaptive Surface 4 3. Chaos 5 1. Frazer, J. (1995). Introduction, An Evolutionary Architecture (Vol. Themes VII): Architectural Association Publications, 1. 5 4. Irene Neuwirth Jewelry 6 5. Kleiburg housing project, 8 6. Geranium stem 11 7. 1-d cellular automata 15 8. Emergence and Determinism Diagram 17 9. Coherence and Noise Diagram 18 10. Farming Parameter Space 19 11. Subjective View of Discourse History 20 12. Natural Systems v Paremtricism 21 13. Core Problematic of Architecture 22 14. Photographic Tower Iterations 23 15. Systemic Compulsion 24 16. Web Morphogenesis 25 17. Chaos Diagram 29 18. Baterial Walker Code Snippet 30 19. Baterial Walker Processing Image Exports 31 20. Life & Death Code Snippet 32 21. Life & Death Processing Image Export 33 22. Culture Genotype code snippet 34 23. Culture Genotype processing image export 35 24. Spring Subdivision Diagram 39 25. SubDiv Spring code snippet 1 40 26. SubDiv Spring code snippet 2 41 27. SubDiv Spring code snippet 3 42 28. SubDiv springnetowrk processing image export 43 29. Subdividing Spring Network 44 30. Subdividing Spring Network 45 31. Predator and Prey close up processing image export 1 46 32. Predator and Prey close up processing image export 2 46 33. Predator and Prey close up processing image export 3 47 34. Predator and Prey close up processing image export 4 47 35. Stigmergy Thematic Image 1 48 36. Stigmergy Thematic image 2 49 37. Stigmergy Processing Image Export 1 50 38. Stigmergy Processing Image Export 2 50 39. Stigmergy Processing Image Export 3 50 40. Stigmergy processing code snippet 51 41. Stigmergy processing image export 52 42. 53 44. 53 46. Stigmergy processing image export 53 43. 53

112

IV. R e f e rences

F i gures 45. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 70. 69. 71. 72. 73. 74. 75. 76. 77. 80. 78. 79. 81. 82. 83. 85. 84. 86. 87. 89. 90. 88. 91. 92. 93. 94.

53 Stigmergy processing image export 54 54 Stigmergy Mover System Code snippet 55 Stigmergy processing image export 56 Stigmergy processing image export 56 Stigmergy processing image export 56 Stigmergy processing image export 57 Stigmergy processing image export 58 Stigmergy processing image export 59 Stigmergy processing image export 60 Stigmergy processing image export 61 Stigmergy processing image export 61 61 Stigmergy processing image export 62 Stigmergy mover system code snippet 2 63 Stigmergy mover system code snippet 3 63 Viipuri Library Alva Aalto 64 Volumetric Space array pseudo code 65 Stigmergy Thematic image 65 Termite Hills, Stigmergy Thematic 66 66 3D stigmergy processing image export 67 68 3D stigmergy with flocking, processing image export 68 68 68 3D stigmergy with flocking, processing image export 69 3D stigmergy with flocking close up, processing image export 70 Stigmergy Thematic 70 Non -Linear Research Facility, using Stigmergy 71 Michael Hansmeyer Fractals Thematic 73 Fractals Pseudo Code 74 Fractal Generator - from Open processing 74 74 A thematic example of the potential of L-systems. 75 L-system processing image export 75 L-System Pseudo Code 75 â&#x20AC;&#x2DC;Onion Skinâ&#x20AC;&#x2122; building diagram using graphed form thresholds 76 Force Directed Network Thematic 76 Edge Bundling & Spring Network Graph example 77 Force Directed Network processing image export 78 Force Directed Network processing image export 79 79 Spring Stacking Boxes 79 Force Directed Spring Network Processing Image export 80 Force Directed Spring Network, close up Processing Image export 80 3D path following processing image export 1 81 3D path following processing image export 2 81

113

References IV. Figures

95. 3D path following pseudo code 81 96. 3D path following close up, processing image export 3 83 97. 3D path following code snippet 83 98. Cellular Automata problematic diagram 84 99. Marc Fornes Cellular Automata thematic images 85 100. 86 101. Cellular Automata, San Francisco simulation rule diagrams 86 104. Cellular Automata thematic images 87 103. Cellular Automata processing code snippet 87 105. Cellular Automata pseudo code 87 102. 87 106. Cellular Automata processing image export 88 107. Cellular Automata processing image export 89 108. The genetic algorithm recipe diagram 90 109. Genetic Algorithms and parametric rules diagram 91 110. Evolving Grid processing image export 92 111. Concept Diagram 1 92 112. Concept Diagrams 2 93 115. Evolving Grids procesing image exports 94 113. 94 114. 94 116. 95 120. 95 117. 95 118. 95 121. 95 119. 95 122. The genetic algorithm problematic 96 123. Future Genetric algorithm concept diagrams 97 124. Genetic algorithm future concept cont. 98 125. Neural Network Critter processing image export, example from Open Processing 102 126. Neural Network Critter processing image export, example from Open Processing 102 127. Neural Network Critter processing image export, example from Open Processing 103 128. 103 129. 103 130. Image stack isosurfaced in Amira, using images from Neural Network Critter sketch 104 132. Volren in Amira, using images from Neural Network Critter sketch 107

114

IV. R e f e rences V.

Appendix 1: Movies 1

SubdividingSpringNetwork (1)

SubdividingSpringNetwork (2)

SubdividingSpringNetwork (3)

SubdividingSpringNetwork (4)

SubdividingSpringNetwork (5)

SubdividingSpringNetwork (6)

SubdividingSpringNetwork (7)

SubdividingSpringNetwork (8)

EvolvingGrid (1)

VI. Appendix 2: Sketches 1

BacterialWalker

CellularAutomata_practice

CultureGenotype

Evolvinggrids_6

evolvinggrids_7

L_System_Swarm_5

L-System-Swarm-8

LifeandDeath

PredatorandPrey

Stigmergy_1

Stigmergy_2

Stigmergy_3

Stigmergy_4

Subdiv_SpringNetwork_3

Subdiv_SpringNetwork_5

Subdiv_SpringNetwork_7

Subdiv_SpringNetwork_9

VSA_Flocking

115