Dynamic Extrusion by Jacob Russo

Dynamic Extrusion

Biologically-inspired computational framework for additive assembly logics using agent-based modeling

Module Name: Computational Design and Design Thinking Module Number: 11600601 Term/Year: Winter Term 2016/17 Examination Number: 49771 Examiner: Prof. Achim Menges Tutors: Ehsan Baharlou, Lauren Vasey, Long Nguyen Institute: Institute for Computational Design and Construction (ICD) Jacob Russo Danny Mazur

Contents Chapter 01: Behavior in Nature_____Page 05 Chapter 02: Agent-based Modeling_____Page 11 Chapter 03: Abstraction_____Page 15 Chapter 04: Behavioral Development_____Page 21 Chapter 05: Results_____Page 27 Chapter 06: Code_____Page 43 Chapter 07: References_____Page 51

Chapter 01 Behavior in Nature

CHAPTER 01

Env.

Stimulus

Org.

Response

“Behavior is the internally coordinated responses (actions or inactions) of whole living organisms (individuals or groups) to internal and/or external stimuli.”1

Fig. 1: Definition of behavior in biological context. (Source: Levitis et al. 2009)

BEHAVIOR IN NATURE We often look at nature and marvel at its beauty. The aesthetic qualities of natural systems have been widely applied to architectural design. However, behavior in nature can provide an equally diverse range of inspiration for design applications. The definition of behavior in a biological context is an ongoing debate. In Animal Behavior Volume 78, Daniel A. Levitis posits that “behavior is the internally coordinated responses (actions or inactions) of whole living organisms (individuals or groups) to internal and/or external stimuli.”1 One way to think of this is that you have an environment, which provides a stimulus to an organism and the organism exhibits some sort of response in the form of an action or inaction (Fig. 1).

For our project, we were specifically interested in how organisms respond to environmental stimuli and coordinate their responses in various ways. Through simple logics, or rules, organisms can demonstrate very complex behavioral patterns. The more organisms there are following the rules, the more complex the system can become. For this reason, we decided to focus on organisms that operate in groups, specifically social insects.

CHAPTER 01

Social Caterpillar Environment

Behavior

Archips cerasivorana

Fig. 2: Social caterpillar Archips cerasivorana. (Source: Medetera 2012)

Our biological role model for this project is the social caterpillar, Archips cerasivoranus. These caterpillars work in groups to create nests from the leaves of their host plant (Fig. 2). What we found fascinating about the caterpillar behavior is their movement from one area of the plant to another and the method by which they build their nest using silk strands to pull the leaves together. The caterpillars use pheromone trails to move efficiently and determine where to navigate.2 The trails act as sort of â&#x20AC;&#x153;attractorsâ&#x20AC;? to guide the caterpillars in their nest building processes. The pheromone trails last for five days, getting weaker over time.

We were interested in exploring the idea of temporal attraction to specific locations within an environment and how the cumulative response to certain environmental cues could be related to the build-up of material, similar to how the caterpillar builds its silk network over time.

CHAPTER 01

(a)

(b)

(c)

(d)

(e)

(f)

Fig. 3: Archips cerasivorana movement around nest during construction. (Source: Firefly403 2015)

We analyzed the nest-building process of the caterpillar, paying specific attention to the movement of groups of caterpillars. The nest construction is shown above at different points in time (Fig. 3). The current position of the group, or groups, of caterpillars is highlighted with a solid circle and previous positions with a dotted circle. We noticed that at certain points, groups will travel longer distances (Fig. 3b), but other times they will stay in the same area (Fig. 3c). Another observation was that multiple groups of caterpillars will sometimes operate in different areas of the nest (Figs. 3e and 3f).

As the caterpillars move around the host plant, they incrementally build up the silk nest through a process of tensioning leaves together with their silk3. The leaves are used as a temporary formwork but are then eaten by the caterpillars to produce more silk. As shown in the sequence above, certain branches and leaf stems remain as a part of the nest skeleton, but the main enclosure of the final nest state comes from the silk. Our main interest was in the growth of the nest through the additive logic of the silk trails, and how the caterpillar movement facilitates this expansion.

CHAPTER 01

(a)

(b)

Fig. 4: Archips cerasivorana silk bridge construction. (Source: Firefly403 2015)

In addition to the relationship between the caterpillar behavior and its effect on the global nest formation, we examined some local behavioral processes within the nest construction framework. At certain points, the caterpillars encounter portions of the host plant that are further away from the nest in its current state (Fig. 3d). Yet, somehow they manage to manipulate these portionsâ&#x20AC;&#x201C;in some cases whole branchesâ&#x20AC;&#x201C;and incorporate them into the nest (Figs. 3e and 3f). We noticed that this was related to the previous observation of multiple groups working in different areas so we decided to delve a bit further into this phenomenon.

What we found was that the caterpillars create silk bridges from the current nest state to the portion of the host plant they aim to include (Fig. 4a). It is unclear how the initial silk strands of the bridge are laid to allow for the bridge construction. However, we were fascinated by this behavior. Here, it seems that smaller subgroups of caterpillars operate on the bridge construction while the larger, main group works on one side of the bridge. As shown above, the silk bridge expands over time resulting in a 3-dimensional silk network. This investigation of our biological role model laid the foundation for our research into behavior in nature. Our next step was to find a method for translating this to a computational approach to behavioral modeling. For this, we chose to explore agent-based modeling.

Chapter 02

Agent-Based Modeling

CHAPTER 02

Fig. 5: Simple reflex agent. (Source: ‘Intelligent agent’ 2017)

AGENT-BASED MODELING Agent-based modeling is a computational method for “simulating the actions and interactions of autonomous agents (both individual or collective entities such as organizations or groups).”4 The goal of this type of modeling is to evaluate the effects of the agents on the whole system. An autonomous agent is a type of intelligent entity, which can interact with its environment by performing actions within the environment based on perceptual information. Similar to the organism in the definition of behavior outlined in the previous chapter, the autonomous agent responds to certain stimuli given by its context. There are various classes of agents, ranging from simple reflex agents (Fig. 5) to learning agents, based on their degree of perceived intelligence and capability.5

For our research, we were interested in the potential of agent-based modeling, using autonomous agents, to abstract biological behavior. With this approach, we saw the opportunity to relate our investigation of the social caterpillar to the development of a design tool for additive assembly and material extrusion processes, such as 3d-printing, based on behavioral logics.

CHAPTER 02

Fig. 6: Emergence in a physical system: formation of complex fractal patterns in snowflakes. (Source: ‘Emergence’ 2017)

One of the reasons agent-based systems are compelling for architects and designers is because of its integration of the notion of emergence. Emergence is a fascinating phenomenon that we see in nature (Fig. 6) as well as computational models such as agent-based system. In the journal Emergence, economist Jeffrey Goldstein defines emergence as “the arising of novel and coherent structures, patterns and properties during the process of self-organization in complex systems.”6 Essentially, complex structures emerge from interactions among less complex entities and these complex structures have properties that are not found in the less complex ones. Thus, it is possible to create systems with simple entities and rulesets that are capable of demonstrating

emergent properties similar to those found in biology. One way to do this is with agent-based systems and it is why we chose this approach for our computational methodology. Many biological processes are inherently efficient and optimized for function. As designers, our aim is to apply paradigms found in nature to architectural systems. Our hypothesis was that agent-based modeling could allow us to extrapolate behavioral patterns from our biological role model and set up a framework for the creation of novel structures through dynamic extrusion.

Chapter 03

Abstraction

CHAPTER 03

(a)

(b)

(c)

(d)

(e)

(f)

Fig. 7: Abstraction of caterpillar movement and nest expansion. (Source: Jacob Russo, Danny Mazur)

ABSTRACTION We began our biomimetic translation from the caterpillar behavior to our computational behavior simulation by attempting to abstract the behaviors of our biological role model. First, we referred back to our previous study of the caterpillar movement around the nest during construction. We were interested in the relationship between the caterpillar movement and the expansion of the silk nest (Fig 7). Of course, not all of the movements of caterpillar groups could be analyzed but this fact led to an interesting consideration: at certain points during the nest construction, other sub-groups of caterpillars, similar to those that work on the silk bridges, may also be working in close proximity to the larger, main groups. It would seem that the larger groups occasionally split up and then reunite in order to maintain an efficient construc-

tion process and cover more area for building up the silk network. This led to the idea to abstract this behavior by creating a way for groups of agents to split up and then reunite as a means to create an expanded network. We will revisit this abstraction in more detail in the next chapter.

CHAPTER 03

(a)

(b)

Fig. 8: Abstraction of caterpillar silk bridge construction. (Source: Jacob Russo, Danny Mazur)

The idea of expansion is not only demonstrated on a global level with the growing of the whole nest, but also on a local level with the construction of the silk bridges. There seems to be an embedded logic to how the bridge mesh is formed. The bridge begins with the reinforcement of a thick central cord, spanning the necessary distance. The bridge then expands outward in multiple directions, presumably to create a stronger tension net with which to reel in the new portion of the host plant. The procedural logic of this process is relatively simple. However, when groups and sub-groups of caterpillars interact within the environment, these simple behavioral patterns give rise to more complex structures. Hence, we see the first phase of the silk bridge (Fig. 8a) morph into a later phase (Fig. 8b), an intricate 3-dimensional silk matrix.

We decided to try to abstract certain principles from this study as well. The idea of integrating a correlation between global and localized expansion was appealing. We thought that by setting up multiple levels of growth within our computational framework, we could achieve a system that would demonstrate emergent properties.

CHAPTER 03

SPECIES CLASS

AGENT CLASS

ACTION SELECTION

STEERING

LIFESPAN

MOVEMENT

Fig. 9: Framework for agent-based system. (Source: Jacob Russo, Danny Mazur)

From the biomimetic abstraction, we began to set up a framework for our computational design (Fig. 9). Our coursework focussed on using the Rhino Python scripting environment as well as Python in Grasshopper for Rhino. This gave us the flexibility to manipulate geometries and processes in Rhino through other means besides the typical Rhino user interface. We began with a relatively simple mover algorithm. Using object oriented programming (OOP), our goal was to build up a behavioral logic starting from a single agent and advancing to multiple agents. Besides the basic movement functionality, we decided to formulate a behavioral repertoire for the agents. We defined various actions that the agents would be able to perform, as well as the ability for them to steer in a particular direction.

In addition, we investigated the idea of giving the agents, or movers, a lifespan. We thought that this would add to the temporal nature of the design process and allow for less predictable outcomes. Once we had developed the individual agent class, we needed a way to introduce groups of agents into the system so we could start to integrate the principles of our biological role model. To do this, we worked on a type of class that could create such groups and manage the agents within them. We called this the â&#x20AC;&#x153;Speciesâ&#x20AC;? class.

CHAPTER 03

AGENT CLASSES

MOVER

SEEKER

Fig. 10: Agent classes. (Source: Jacob Russo, Danny Mazur)

The Species class gave us the opportunity to experiment with groups of agents. This was interesting because we could now use these groups, and their ability to perform various actions, to begin to relate their movement to the build up of material. This was the basis for our abstraction of the caterpillar group behavior. We then began to develop a way to implement the concept of temporal attraction, which came up in our initial research into the biological role model. To reiterate, our early observations of how groups of caterpillars would be drawn to certain areas of the nest led to the idea of agents that would be affected by their environment in different ways over time. We thought that this could be manifested as a behavioral characteristic of some of the agents. We decided to

come up with an agent class of the mover type, which would have similar functionality as the original mover but could also include new methods, such as a seek definition. This would allow us to incorporate the temporal attraction principle into some of the agent groups. For this reason, we called this new class of agents the â&#x20AC;&#x153;Seekerâ&#x20AC;? class.

Chapter 04

Behavioral Development

CHAPTER 04

Fig. 11: Seeker species at final seek location, elevation; complete travel paths shown. (Source: Jacob Russo, Danny Mazur)

BEHAVIORAL DEVELOPMENT We then began to implement the Seeker class to develop the behavioral manifestation of temporal attraction. Initially, we set up one Seeker species and gave it a point in space to seek. The species would start in a cluster but then slightly move apart during the seek process before coming back together at the specified location. By visualizing the movement trails of the species, we could see how this expansion related to their movement. We then added more points in space and had the Seeker species become attracted to different points over various time intervals. The result was a network of trails, or bridges, from the various temporal attraction points (Fig. 11). The density of the trails was higher at the points, where they species would hover before moving on to the next location.

Once we had explored the seek behavior with one species, we were interested in adding more species to the system and have some start from different locations as opposed to clustered together (Fig. 12). We were interested in how the various species, like the caterpillar groups, would contribute to the growth of a larger network. We analyzed a sequence with four species as they moved to the different points in the environment. While the groups started out separately (Figs. 12b and 12d), after the first seek location (Fig. 12e), they united as a larger group and began to travel together. We were interested in further developing the group and subgroup dynamic and the potential for emergent growth so we introduced another way for the species to interact with their environment.

CHAPTER 04

(a)

(b)

(c)

(d)

(e)

(f)

(g)

(h)

(i)

(j)

Fig. 12: Seeker species partial seek sequence, elevations and plans; complete travel paths shown. (Source: Jacob Russo, Danny Mazur)

CHAPTER 04

Fig. 13: Seeker species avoiding spherical surface, perspective. (Source: Jacob Russo, Danny Mazur)

In order to advance the development of our behavioral logics and their relationship to additive assembly logics, we introduced another type of action in the Seeker species repertoire. This behavior gave the seekers the ability to avoid surfaces that they came upon in their paths of travel. At first, we experimented with avoiding one spherical surface (Fig. 13). We chose a sphere because it lent itself to the type of dynamic expansion we thought would relate well to our biological role model research. We looked at five difference scenarios with different locations and sizes of spherical surfaces for the species to avoid (Fig. 14). The initial species setup was identical to the previous seek sequence to compare results.

Our hypothesis was proven correct: introducing the surface elements into the environment for the species to avoid while seeking, resulted in the larger groups having to split into smaller sub-groups to navigate from location to location (Figs. 14c, 14e, and 14g). We also observed that the altered trajectories of the species from the avoidance action led to the merging of groups whose paths had previously not intersected (Fig. 14j). This, in turn, led to a more emergent extrusion pattern of the species trails. The network began to display a more responsive nature due to the addition of the avoidance behavior.

CHAPTER 04

(a)

(b)

(c)

(d)

(e)

(f)

(g)

(h)

(i)

(j)

Fig. 14: Seeker species avoiding spherical surface, elevations and plans; complete travel paths shown. (Source: Jacob Russo, Danny Mazur)

Chapter 05

Results

CHAPTER 05

Fig. 15: Seeker species avoiding spherical surfaces, perspective. (Source: Jacob Russo, Danny Mazur)

RESULTS The behavioral development phase led us to our final experiment and results. This involved the combination of the seek and avoid behaviors from the previous test with the addition of multiple spherical surfaces for the species to avoid (Fig. 15). The initial species setup was identical to the previous seek and avoid sequence to compare results. The setup also included all of the five spheres that were tested separately in the previous sequences. The spheres were placed at various locations to intersect with different species travel paths at various time intervals. During the previous experiments with each sphere being tested individually, the cumulative effect of this environmental setup was not apparent. However, with all five surfaces now within seek and avoid framework, the outcome was quite fascinating.

The merging of paths was one result that was enhanced (Fig. 16d and 16f). The sub-group effect was also increased with more surfaces to avoid necessitating more navigational divergence (Fig. 16g). However, the final outcome seemed to encompass certain properties that embodied a complexity not seen in the previous examples. The characteristics of growth and expansion that we saw in the nest construction processes of our biological role model seemed to be teased out by the combination of our relatively simple behavioral rules. What we ended up with was a structure that begins to integrate the notion of emergence with a dynamic paradigm for material extrusion.

CHAPTER 05

(a)

(b)

(c)

(d)

(e)

(f)

(g)

(h)

(i)

(j)

Fig. 16: Seeker species avoiding spherical surfaces, elevations and plans; complete travel paths shown. (Source: Jacob Russo, Danny Mazur)

CHAPTER 05

Fig. 17: Final experiment showing main group, sub-groups, and individuals, perspective. (Source: Jacob Russo, Danny Mazur)

Fig. 18: Final experiment showing main group, sub-groups, and individuals, top view. (Source: Jacob Russo, Danny Mazur)

CHAPTER 05

Fig. 19: Final experiment showing seek and avoid surface behaviors, perspective. (Source: Jacob Russo, Danny Mazur)

Fig. 20: Final experiment showing seek and avoid surface behaviors, close-up. (Source: Jacob Russo, Danny Mazur)

CHAPTER 05

Fig. 21: Rendering of final experiment, close-up. (Source: Jacob Russo, Danny Mazur)

Fig. 22: Final 3d printed model, top. (Source: Jacob Russo, Danny Mazur)

Fig. 23: Final 3d printed model, side. (Source: Jacob Russo, Danny Mazur)

Fig. 24: Final 3d printed model, detail. (Source: Jacob Russo, Danny Mazur)

Fig. 25: Final 3d printed model, detail. (Source: Jacob Russo, Danny Mazur)

Fig. 26: Final 3d printed model, side. (Source: Jacob Russo, Danny Mazur)

Fig. 27: Final 3d printed model, detail. (Source: Jacob Russo, Danny Mazur)

Fig. 28: Final 3d printed model, side. (Source: Jacob Russo, Danny Mazur)

Fig. 29: Final 3d printed model, side. (Source: Jacob Russo, Danny Mazur)

Fig. 30: Final 3d printed model, side. (Source: Jacob Russo, Danny Mazur)

Fig. 31: Final 3d printed model, detail. (Source: Jacob Russo, Danny Mazur)

Chapter 06

Code

CHAPTER 06

Fig. 32: Grasshopper definition including Python Script components. (Source: Jacob Russo, Danny Mazur)

CHAPTER 06

import rhinoscriptsyntax as rs import VectorMethods as vm import random as r r.seed(seed) import perlin sn = perlin.SimplexNoise() #Basic Mover class class Mover: def __init__(self,pos,vel,acc,mass = 10): self.pos = pos self.vel = vel self.acc = acc self.mass = mass self.upperBounds = 200 self.lowerBounds = 0 self.maxVel = 10 self.lifespan = 100 def update(self): self.lifespan -= 1 self.vel = rs.VectorAdd(self.vel,self.acc) self.vel = vm.VectorConstrain(self.vel,self.maxVel,0) #self.vel = rs.VectorScale(self.vel,0.95) #dampening self.pos = rs.VectorAdd(self.pos,self.vel) self.acc = [0,0,0] #self.checkEdges() def checkEdges(self): #wrapping environment for i in range(3): if(self.pos[i] < self.lowerBounds): self.pos[i] = self.upperBounds - 0.01 if(self.pos[i] > self.upperBounds): self.pos[i] = self.lowerBounds + 0.01 """ #bouncing environment for i in range(3): if(self.pos[i] < self.lowerBounds): self.vel[i] *= -1 self.pos[i] = self.lowerBounds if(self.pos[i] > self.upperBounds): self.vel[i] *= -1 self.pos[i] = self.upperBounds """ def applyForce(self,force): thisAcc = rs.VectorScale(force,(1/self.mass)) self.acc = rs.VectorAdd(thisAcc,self.acc) def gravAttractTo(self,otherMover): """ Apply a gravitational force to this mover that moves it toward the mover you pass in. """ G = 2 rVec = rs.VectorSubtract(otherMover.pos,self.pos) #attractor is another mover v = vm.VectorConstrain(rVec,10,5) Fig. 33: Python script, page 1. (Source: Jacob Russo, Danny Mazur)

CHAPTER 06

rDist = rs.VectorLength(v) rUnitVec = rs.VectorUnitize(rVec) magnitude = (G*self.mass*otherMover.mass)/(rDist*rDist) forceGrav = rs.VectorScale(rUnitVec,magnitude) self.applyForce(forceGrav) def springTo(self,otherMover): restLen = self.mass + otherMover.mass k = 0.1 #strength of spring dirVec = rs.VectorCreate(self.pos,otherMover.pos) currentLen = rs.VectorLength(dirVec) stretch = currentLen - restLen #direction dir = rs.VectorUnitize(dirVec) #mag mag = -k * stretch forceSpring = rs.VectorScale(dir,mag) self.applyForce(forceSpring) def isDead(self): if self.lifespan < 0: return True else: return False def op(self): plane = rs.PlaneFromNormal(self.pos,self.vel) return plane #Species class. Manages all Movers. class Species: def __init__(self): self.mList = [] self.pos = [0,50,0] self.vel = vm.VectorRandom(r,r.uniform(0.5,3)) def addMover(self): #adds Mover within Species mPos = self.pos vel = vm.VectorRandom(r,r.uniform(0,1.5)) acc = vm.VectorRandom(r,r.uniform(0,2)) mass = r.uniform(6,15)

if r.randint(0,3) == 0: m = Vehicle(mPos,vel,acc,mass) elif r.randint(0,3) == 1: m = Vehicle([50,200,20],vel,acc,mass) elif r.randint(0,3) == 2: m = Vehicle([-20,-80,20],vel,acc,mass) else: m = Vehicle(vm.VectorRandom(r,r.uniform(0,50)),vel,acc,mass) #m = Vehicle(mPos,vel,acc,mass) self.mList.append(m) def applyForce(self,force): for m in self.mList: Fig. 34: Python script, page 2. (Source: Jacob Russo, Danny Mazur)

CHAPTER 06

m.applyForce(force) def gravAttractTo(self,otherMover): for m in self.mList: m.gravAttractTo(otherMover) def update(self): #update ps pos self.pos = rs.VectorAdd(self.pos,self.vel)

#deal with movers self.addMover() for i,m in enumerate(self.mList): if m.isDead(): self.mList[i] = None else: m.update() self.mList = filter(lambda a: a != None, self.mList) #removes all Nones from list def getMasses(self): massList = [] for m in self.mList: massList.append(m.mass) return massList def getPositions(self): posList = [] for m in self.mList: posList.append(m.pos) return posList def getOrientationPlanes(self): opList = [] for m in self.mList: plane = m.op() opList.append(plane) return opList #Vehicle class of type Mover class Vehicle(Mover): def __init__(self,pos,vel,acc,mass): Mover.__init__(self,pos,vel,acc,mass) self.maxSteerForce = 50 def seek(self,targetVec): direction = rs.VectorCreate(targetVec,self.pos) desired = vm.VectorScaleTo(direction,self.maxVel) self.calcAndApplySteerFromDesired(desired) def arrive(self,targetVec): radius = 20 dist = rs.Distance(self.pos,targetVec) if dist > r: self.seek(targetVec) else: directionVec = rs.VectorCreate(targetVec,self.pos) desiredMag = (dist/radius) * self.maxVel Fig. 35: Python script, page 3. (Source: Jacob Russo, Danny Mazur)

CHAPTER 06

desired = vm.VectorScaleTo(directionVec,desiredMag) self.calcAndApplySteerFromDesired(desired) def avoidSurface(self,surface): u,v = rs.SurfaceClosestPoint(surface,self.pos) cp = rs.EvaluateSurface(surface,u,v) #closest point dist = rs.Distance(cp,self.pos) tooClose = 30 if dist < tooClose: #find desired vel dir = rs.VectorCreate(self.pos,cp) desired = vm.VectorScaleTo(dir,self.maxVel) self.calcAndApplySteerFromDesired(desired)

def calcAndApplySteerFromDesired(self,desired): steerForce = rs.VectorSubtract(desired,self.vel) steerForce = vm.VectorConstrain(steerForce,self.maxSteerForce,0) self.applyForce(steerForce) psList = [] for i in range(numOfPS): ps = Species() psList.append(ps) #vehicle = Vehicle([0,0,100],[0,0,6],[0,0,0],50) #vehicle1 = Vehicle([0,10,100],[0,0,6],[0,0,0],50) ps = Species() for i in range(numMovers): p = ps.addMover() #ps.gravAttractTo(aMover) timeList = [] for t in range(time): #moment in time posList = [] for vehicle in ps.mList: vehicle.avoidSurface(srfs[0]) vehicle.avoidSurface(srfs[1]) vehicle.avoidSurface(srfs[2]) vehicle.avoidSurface(srfs[3]) vehicle.avoidSurface(srfs[4]) #Apply gravity: #vehicle.applyForce([0,0,-1]) if t < 50: vehicle.seek(targets[1]) elif 50 < t < 100: vehicle.seek(targets[2]) elif 100 < t < 150: vehicle.seek(targets[3]) else: vehicle.seek(targets[0]) vehicle.update() posList.append(vehicle.pos) infoForThisMomentInTime = [ps.getOrientationPlanes(),ps.getMasses(),posList] timeList.append(infoForThisMomentInTime) a = timeList Fig. 36: Python script, page 4. (Source: Jacob Russo, Danny Mazur)

Chapter 07

References

CHAPTER 07

In-text Citations [1] Levitis, D, Lidicker, WZ Jr, & Freund G, 2009, ‘Behavioural biologists do not agree on what constitutes behaviour’, Animal Behaviour, vol. 78, pp. 103–110. [2] Pescador, A n.d., The processionary caterpillar Hylesia lineata Saturniidae. Available from: http://facultyweb.cortland.edu/fitzgerald/hylesia.html. [02 February 2017]. [3] Firefly403 2015, Social leaf tying caterpillar Archips, YouTube video, 18 Nov. Available from: https://www. youtube.com/watch?v=Hrg3WsGBeoc. [10 January 2017]. [4] Agent-based model 2017, Wikipedia, wiki, 5 March 2017. Available from: https://en.wikipedia.org/wiki/Agentbased_model. [01 March 2017]. [5] Russell, SJ, Norvig, P, 2003, Artificial Intelligence: A Modern Approach, 2nd edn, Prentice Hall, Upper Saddle River, New Jersey. [6] Goldstein, J, 1999, ‘Emergence as a Construct: History and Issues’, Emergence, vol. 1, no. 1, pp. 49-72.

References Emergence 2017, Wikipedia, wiki, 19 February 2017. Available from: https://en.wikipedia.org/wiki/Emergence. [02 March 2017]. Intelligent agent 2017, Wikipedia, wiki, 27 February 2017. Available from: https://en.wikipedia.org/wiki/Intelligent_ agent. [02 March 2017]. Jake Hebbert 2013, NOC6 Autonomous Agents: 01, YouTube video, 16 Dec. Available from: https://www.youtube.com/watch?v=mk4lc9Zy5jc. [19 February 2017]. Medetera 2012, Larvae of Archips cerasivoranus, image. Available from: https://commons.wikimedia.org/wiki/ File:Larvae_of_Archips_cerasivoranus.JPG. [01 March 2017].