27.6.11

Student Conference on Complexity Science

If you are a PhD student researching a complexity science problem, then you are invited to submit an abstract for the first annual Student Conference on Complexity Science. This conference is an opportunity for postgraduate students to network and meet others in the complexity science community.

The SCCS will be held at the Stripe Theatre, Winchester University, from 5th to 6th of August 2011; attendance is free of charge. All prospective attendees to the conference must submit an abstract, and be prepared to either give a 20 minute talk, or to present a poster to share their research.

Due to the interdisciplinary nature of complex systems, research presented at this conference is expected to span a broad range of scientific disciplines. Work may be theoretical or applied and, for example, could cover social systems, networks, ecosystem dynamics, evolution, or non-linear systems.

Prizes will be awarded for the best presentation and for the best poster at the close of the conference.
If you are interested in presenting your work at this conference, please submit an abstract to sccs@soton.ac.uk by 8th July in the following format:
  • Email subject: ABSTRACT - Poster/Presentation (please specify your preference)
  • Project title
  • Your name, University/department and supervisor(s)
  • Contact information
  • The abstract, which must have a maximum of 250 words and should outline your project, summarise your methodology and results, and include any conclusions you have drawn.
If you have any queries, please do not hesitate to contact the SCCS organisation team on sccs@soton.ac.uk.

24.6.11

PhD - first step

So first year over, now its on to some new research.


My first thought was, where do I go next?

My PhD is aimed at a real-life problems. My case study is a corridor area in Belize, in central america.

The issues remain the same as with the hedgehog work. How do mammals move through the landscape? How will increased habitat fragmentation affect the movement of mammals through the landscape? How do we measure landscape permeability? How can we best model the effects of landscape structure on the movement of mammals in a landscape?


These questions have huge implications on the persistence of populations in a landscape and on the amount of disturbance and development that a landscape can absorb before a population reaches a threshold tipping point. My research is really focused on questions surrounding ecosystem function and resilience.
"To halt the decline of an ecosystem, it is necessary to think like an ecosystem."
Douglas P. WheelerEPA Journal,September-October 1990
The overall goal of my research is to attempt to understand how a species views and interacts with its environment. Exploring these issues and gaining some understanding of the relationship between animals and their environment can help us understand ecosystems function and how anthropogenic processes may affect ecosystem processes.

15.6.11

Final thoughts on Netlogo model

I was really happy with how things turned out with my first foray into agent-based modelling.

My friend Melissa first got me interested in Netlogo and I have to say it was a perfect choice for a short-term relatively simplified and low-level model. I avoided the necessity of having to learn a new programming language as I found the netlogo language easy, intuitive and quick to pick up.

I would recommend anyone new to programming or agent-based modelling to start with something like Netlogo to break yourself in gently.

Some negatives, however, obviously I am no expert at netlogo modelling, but my first experience left me feeling that the scope of the language was limited and that if I wanted to explore some more complicated and detailed modelling options then I would need to progress to a language that allowed me more freedom. The level of automatic generation of output and ready-made agents and patches makes netlogo an ideal starting point, but not necessarily an ideal language to really start exploring what agent-based modelling can do.

next post: java

13.6.11

Netlogo Code (summer project)

breed [randomH]    ;; create two breeds of turtle to compare random walks vs the 'real' hedghogs in any landscape
breed [hedgehog]
breed [arable]
breed [ pasture]
breed [ garden]
breed [ wood]
breed [ water]
breed [ urban]
breed [ road]

turtles-own [energy Harable Hpasture Hwood Hgarden Hwater Hurban Hroad]                ;;energy relates to the cost of the path taken by the hedgehogs

patches-own [habitat cost visit]    ;; habitat assigns a land-cover type to each patch colour  
                                    ;;includes the cost of the habitat as a patch feature - allowing hedgehogs to search for low cost patches


globals [timestep time hour]


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  setup patches and turtles   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup
  clear-all
  set time 0
  set hour 0
  set timestep 1
  setup-patches
  setup-turtles
end

to setup-turtles                        ;; creates 10 of each breed, assigning the paw footprint for an icon.  create-randomH Number-of-Random-Hedgehogs-red ;; the random hedgehogs are red, the 'real' are white.   create-hedgehog Number-of-Non-Random-Hedgehogs-white
    ask turtles [set shape "hedgehog paw"]  ;;this is the footprint other renamed to hedgehog - the closest icon resembling a hedgehog!  ask turtles [
    if breed = randomH [set color red]
    if breed = hedgehog [set color white]         ;;need to find a colour that shows on map and on the plot  ]
  ask turtles [setxy random-xcor random-ycor]   ;; sets the newly created turtles at random locations on the map  end

                                        
to setup-patches 
  colour-turtles
  ask turtles [repeat 100 [expand-habitats] ]         ;; proportions are supposed to be approx pasture/arable - 30%, garden/urban - 10%, wood - 13%, roads - 5%, water - 2%  ask patches [
    ifelse show-cellcosts? [
      set plabel cost] [
      set plabel ""]
    ifelse show-habitat? [
      set plabel habitat] [
      set plabel ""]
      ]
  ask patches [set visit 5]
  ask patches [
    if pcolor = yellow [set cost 150 set habitat "arable"]
    if pcolor = green [set cost 10 set habitat "pasture"]
    if pcolor = brown [set cost 1 set habitat "wood"]
    if pcolor = lime [set cost 5 set habitat "garden"]
    if pcolor = grey [set cost 15 set habitat "urban"]
    if pcolor = blue [set cost 300 set habitat "water"]
    if pcolor = black + 2 [set cost 150 set habitat "road"]
  ] 
  ask patches [
    if random 100 <= fragmentation-of-habitats
    [swap self one-of patches]
    ]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  go statement   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
to go                   ;;need to include all procedures here if they are required to run during the model run
  set time time + 1
  set hour (time * timestep)
  cost-path
 
  if hour mod 24 >= 6 and hour mod 24 < 18 [
  move-randomH
  ifelse day-and-night-mode? [
    repeat 10 [move-hedgehog-day]][
    move-hedgehog]
  ]
 
  if hour mod 24 >= 18 or hour mod 24 < 6 [
  move-randomH
  ifelse day-and-night-mode? [
    repeat 10 [move-hedgehog-night]][  ;; this increments tick counter by one everytime the model completes a single turn of each procedure
    move-hedgehog]
  ]
 
  do-plots      
  if days = Number-of-days [stop]  ;; allows output to run faster as it updates after every tick onlyend
 

;;;;;;;;;;;    do reports on interface for length of time passed in the model  ;;;;;;;;;;;;;;;;;

 
to-report days
  report hour / 24
end

to-report hours
  report hour - (floor days * 24)
end
 
 
;;;;;;;;;;;;;;     defines how to create the landscape ;;;;;;;;;;;;;;;;;;;;;;;;;;; 

to colour-turtles                                        ;; creates 7 turtles, one for each of the habitats
  create-arable 1
  create-pasture 1
  create-wood 1
  create-garden 1
  create-water 1
  create-urban 1
  create-road 1 
  ask turtles [
    set Harable 312
    set Hpasture 313
    set Hwood 173
    set Hgarden 107
    set Hwater 19
    set Hurban 107
    set Hroad 51]
  ask turtles [
    if breed = arable [set color yellow]
    if breed = pasture [set color green]
    if breed = wood [set color brown]
    if breed = garden [set color lime]
    if breed = water [set color blue]
    if breed = urban [set color grey]
    if breed = road [set color black + 2]                                       
  ]                                     
  ask turtles [
    setxy random-xcor random-ycor
    hide-turtle
    move-to patch-here
    set pcolor color]  ;; puts turtles in a random place in landscape and sets patch color to turtle colourend

to expand-habitats
  ifelse (Harable = 0) and (Hpasture = 0) and (Hwood = 0) and (Hgarden = 0) and (Hwater = 0) and (Hurban = 0) and (Hroad = 0) [stop] [
    expand-habitatarable
    expand-habitatpasture
    expand-habitatwood
    expand-habitatgarden
    expand-habitatwater
    expand-habitaturban
    expand-habitatroad
  ]
end 

;;;;;;;;;;;;;functions for 'building' habitats from scratch ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; one run of each function only creates 8 cells. The functions need to be repeated in order to create the appropriate number of cellsto expand-habitatarable
  ask arable [
    if all? patches [pcolor != black] [stop]
    if Harable = 0 [stop]
    ifelse all? neighbors [pcolor != black]
      [move-to one-of patches with [pcolor = black]
        set pcolor color
        reduce-colours]
      [ifelse all? neighbors4 [pcolor != black] [
         move-to one-of neighbors with [pcolor = black]
         set pcolor color
         reduce-colours
         ][
         move-to one-of neighbors4 with [pcolor = black]
         set pcolor color
         reduce-colours]
         ]
  ]
end

to expand-habitatpasture
  ask pasture [
    if all? patches [pcolor != black] [stop]
    if Hpasture = 0 [stop]
    ifelse all? neighbors [pcolor != black]
      [move-to one-of patches with [pcolor = black]
        set pcolor color
        reduce-colours]          
      [ifelse all? neighbors4 [pcolor != black] [
         move-to one-of neighbors with [pcolor = black]
         set pcolor color
         reduce-colours
         ][
         move-to one-of neighbors4 with [pcolor = black]
         set pcolor color
         reduce-colours]
  ]
  ]
end

to expand-habitatwood
  ask wood [
    if all? patches [pcolor != black] [stop]
    if Hwood = 0 [stop]
    ifelse all? neighbors [pcolor != black]
      [move-to one-of patches with [pcolor = black]
        set pcolor color
        reduce-colours]       
      [ifelse all? neighbors4 [pcolor != black] [
         move-to one-of neighbors with [pcolor = black]
         set pcolor color
         reduce-colours
         ][
         move-to one-of neighbors4 with [pcolor = black]
         set pcolor color
         reduce-colours]
  ]
  ]
end

to expand-habitatgarden
  ask garden [
    if all? patches [pcolor != black] [stop]
    if Hgarden = 0 [stop]
    ifelse all? neighbors [pcolor != black]
      [move-to one-of patches with [pcolor = black]
        set pcolor color
        reduce-colours]         
      [ifelse all? neighbors4 [pcolor != black] [
         move-to one-of neighbors with [pcolor = black]
         set pcolor color
         reduce-colours
         ][
         move-to one-of neighbors4 with [pcolor = black]
         set pcolor color
         reduce-colours]
      ]
  ]
end

to expand-habitatwater
  ask water [
    if Hwater = 0 [stop]
    if all? patches [pcolor != black] [stop]
    ifelse all? neighbors [pcolor != black]
      [move-to one-of patches with [pcolor = black]
        set pcolor color
        reduce-colours]          
      [ifelse all? neighbors4 [pcolor != black] [
         move-to one-of neighbors with [pcolor = black]
         set pcolor color
         reduce-colours
         ][
         move-to one-of neighbors4 with [pcolor = black]
         set pcolor color
         reduce-colours]
      ]
  ]
end

to expand-habitaturban
  ask urban [
    if all? patches [pcolor != black] [stop]
    if Hurban = 0 [stop]
    ifelse all? neighbors [pcolor != black]
      [move-to one-of patches with [pcolor = black]
        set pcolor color
        reduce-colours]         
      [ifelse all? neighbors4 [pcolor != black] [
         move-to one-of neighbors with [pcolor = black]
         set pcolor color
         reduce-colours
         ][
         move-to one-of neighbors4 with [pcolor = black]
         set pcolor color
         reduce-colours]
      ]
  ]
end

to expand-habitatroad
  ask road [
    if all? patches [pcolor != black] [stop]
    if Hroad = 0 [stop]
    ifelse all? neighbors [pcolor != black]
      [move-to one-of patches with [pcolor = black]
        set pcolor color
        reduce-colours]
      [ifelse all? neighbors4 [pcolor != black] [
         move-to one-of neighbors with [pcolor = black]
         set pcolor color
         reduce-colours
         ][
         move-to one-of neighbors4 with [pcolor = black]
         set pcolor color
         reduce-colours]
      ]
  ]
end

;;;; function to reduce number of habitat cells by one each time a new cell is created ;;;;;

to reduce-colours
  let tempcolor 0
  set tempcolor [pcolor] of patch-here
  if tempcolor = yellow [set Harable Harable - 1]
  if tempcolor = green [set Hpasture Hpasture - 1]
  if tempcolor = brown [set Hwood Hwood - 1]
  if tempcolor = lime [set Hgarden Hgarden - 1]
  if tempcolor = blue [set Hwater Hwater - 1]
  if tempcolor = grey [set Hurban Hurban - 1]
  if tempcolor = black + 2 [set Hroad Hroad - 1]
end

;;;;;;;;;;;;; don't allow a turtle to re-visit a cell it has visited recently ;;;;;;;;;;;;;

to swap [original new]
  let oldcolor 0
  let newcolor 0
  ask original [set oldcolor pcolor]
  ask new [set newcolor pcolor]
  ask original [set pcolor newcolor]
  ask new [set pcolor oldcolor]
end

;;;;;;;;;;;;;;;;;;;;;;;;   move turtles   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 
to move-randomH
  ask randomH [pen-down]                             
  ask randomH [right random 360 forward 1]
end

to move-hedgehog
  ask hedgehog[pen-down]
  ask patches [set visit visit - 1]
  ask hedgehog [
      face one-of neighbors with-min [cost]
      forward 1]
end

to move-hedgehog-day ;; if patch is not wood, move to lowest cost cell until you reachwood  ask hedgehog [pen-down]    ;; ensure hedgehogs reach desired colour before the function finishes  ask patches [set visit visit - 1]
  ask hedgehog [ 
    ifelse pcolor = brown
       [stop]
       [face one-of neighbors with-min [cost]
        forward 1]
      ]                        
end

to move-hedgehog-night ;;if patch is not preferred eating habitat, move to the lowest cost cell until you reach a preferred eating habitat  ask hedgehog [pen-down]
  ask patches [set visit visit - 1]
  ask hedgehog [
    if (pcolor = green) or (pcolor = lime) [stop]
    ifelse any? neighbors with [pcolor = lime] [
      face one-of neighbors with [pcolor = lime]
      forward 1][
        ifelse any? neighbors with [pcolor = green] [
          face one-of neighbors with [pcolor = green]
          forward 1][
            face one-of neighbors with-min [cost]
            forward 1]
      ] 
  ]                                  
end

;;;;;;;;;;;;;;;evaluate the cost of each path taken by a turtle    ;;;;;;;;;;;;;;;;;;;;;

to cost-path                       ;;ok this is the cost of the path taken by the hedgehogs so far in the model....
  ask turtles [
      if pcolor = green [set energy energy + 10]
      if pcolor = grey [set energy energy + 15]
      if pcolor = brown [set energy energy + 1]
      if pcolor = lime [set energy energy + 5]
      if pcolor = black + 2 [set energy energy + 150]        
      if pcolor = blue [set energy energy + 300]
  ]
  ask turtles [
    ifelse show-costpaths?
    [set label energy]
    [set label ""]
  ]
end 

;;;;;;;;;;draw the plots for mean path cost for both turtle breeds   ;;;;;;;;;;;;;;;;
 
to do-plots                               ;;this sets up and runs the plot box in the interface screen. titles need to match EXACTLY in order for it to work.
  set-current-plot "Average Total Path Cost for Random and Non-Random Hedgehogs"
  set-current-plot-pen "Random Hedgehogs"
  plot mean [energy] of randomH
  set-current-plot-pen "Non-Random Hedgehogs"
  plot mean [energy] of hedgehog
end

Netlogo models

Ok, so now I've tested some least-cost models against empirical data of hedgehog dispersal I can use the best-fit least cost model as the basis for some exploratory agent-based simulations.

Luckily there was one clear winner in the least-cost model analysis so I can be fairly confident that this provides a good fit to the way that hedgehoge actually view and move around the landscape. With this in mind I simplified things abit by reducing the number of habitat types from 22, from the original GIS maps, to 7 in the simulations. Whilst this sounds dramatic, it was logical and simply meant lumping all water features together into a single habitat, all urban features together etc. Most of the habitats that we lumped together were given the same cost value anyway, but to clarify, this is how I simplified the landscape:

The proportions of each landscape were for the most part arbitrary, although were estimated from the original GIS maps.

So.... Netlogo. The building of the model was fairly straightforward. Netlogo is brilliant at making it easy to get something up and running fairly quickly. Turtles represent agents and the simplified language and syntax of netlogo makes it really easy to get the turtles to move around in a random direction at every time step.

Of course, by using the least-cost model as a base, turtles were amended so that they searched the cells in their immediate neighbourhood and moved to the cell of the least cost. Sample code is below:

to move-hedgehog
  ask hedgehog[pen-down]
  ask patches [set visit visit - 1]
  ask hedgehog [
      face one-of neighbors with-min [cost]
      forward 1]
end

The biggest problem I faced with the enitre netlogo model was how to construct the landscape. It is easy to generate different habitats by stating which cells to be of which colour(habitat). What is much harder to get a landscape to develop on its own, randomly each time the simulation is run, and then for the landscape to represent some level of fragmentation. This was particularly tricky and get me and my supervisor busy for a while in coming up with suitable ideas. In the end, we 'seeded' the habitats, so that each habitat started at a random cell and moved outward to neighbouring cells. If the cell it wanted to convert to its habitat is alreayd assigned it jumps to a free random cell on the landscape.

Netlogo code (this was done for each of the 7 habitat types):

to expand-habitatarable
  ask arable [
    if all? patches [pcolor != black] [stop]
    if Harable = 0 [stop]
    ifelse all? neighbors [pcolor != black]
      [move-to one-of patches with [pcolor = black]
        set pcolor color
        reduce-colours]
      [ifelse all? neighbors4 [pcolor != black] [
         move-to one-of neighbors with [pcolor = black]
         set pcolor color
         reduce-colours
         ][
         move-to one-of neighbors4 with [pcolor = black]
         set pcolor color
         reduce-colours]
         ]
  ]
end

the method to used to call the habitat methods:

to expand-habitats
  ifelse (Harable = 0) and (Hpasture = 0) and (Hwood = 0) and (Hgarden = 0) and (Hwater = 0) and (Hurban = 0) and (Hroad = 0) [stop] [
    expand-habitatarable
    expand-habitatpasture
    expand-habitatwood
    expand-habitatgarden
    expand-habitatwater
    expand-habitaturban
    expand-habitatroad
  ]
end

Fragmentation was achieved by swapping cells with other random cells at a given probability. 50% probability of swapping leads to 100% fragmentation. (The definition of fragmentation is actually really difficult to find so this is a good enough demonstration for these purposes):


The extension to the model involved giving the hedgehogs a bit more realistic behaviour, so instead of simply choosing the nearest cell with the lowest cost at every step, they mimicked real hedgehogs by choosing habitat depending on the time of day: i.e. during the daytime, they preferred cover (forest) as they would in reality in order to rest, and during the night time they preferred areas where they could feed (pasture, gardens etc):

to move-hedgehog-day                        
  ask hedgehog [pen-down]                  
  ask patches [set visit visit - 1]
  ask hedgehog [ 
    ifelse pcolor = brown
       [stop]
       [face one-of neighbors with-min [cost]
        forward 1]
      ]                        
end

to move-hedgehog-night                      
  ask hedgehog [pen-down]
  ask patches [set visit visit - 1]
  ask hedgehog [
    if (pcolor = green) or (pcolor = lime) [stop]
    ifelse any? neighbors with [pcolor = lime] [
      face one-of neighbors with [pcolor = lime]
      forward 1][
        ifelse any? neighbors with [pcolor = green] [
          face one-of neighbors with [pcolor = green]
          forward 1][
            face one-of neighbors with-min [cost]
            forward 1]
      ] 
  ]                                  
end

I'm currently trying to find a way to upload the netlogo model as an applet and will post it when I can. The code to the full model can be found in the links on the left.
In a nutshell, by looking at the average cost of a path taken by any hedgehog in any landscape, if you look at the hedgehogs that move simply by least-cost pathways, the average cost of path increases dramatically as the landscape becomes more fragmented. If you look at the hedgehogs with some differentation between night and day, then there average path cost stays more or less the same with any level of fragmentation:


Fig 1. a) Simple hedgehogs,                                               b) hedgehogs with day and night preferences










If there are any questions about Netlogo, or how to specifically code for similar process as I've outlined here then please get in touch.

9.6.11

Validation using empirical data and GIS datasets

Before I start with my first attempt at an agent-based simulation in netlogo, I need to explain the point of the work.

My summer project is entitled, "Modelling mammalian movements in fragmented landscapes: exploring and integrating least-cost models and agent-based simulations".


The general idea was re-implement a study already published (Driezen et al, 2007. Evaluating least-cost model predictions with empirical dispersal data: A case-study using radio-tracking data of hedgehogs. Ecological Modelling 209: 314-322) and then extend the study by creating an agent-based simulation with which to add additional realistic behaviours to 'hedgehogs' to see if this extended our ability to understand and explore the way hedgehogs move around the landscape.


I got involved with this paper as one of my supervisors (Patrick Doncaster) collected the data for the original study, rather than because I have any particular interest in hedgehogs (although they are pretty cute!).

Least-cost models essentially give a value to each habitat type in a landscape. The model is species-specific and generated from expert knowledge of how the species in question views the landscape. Values represent the cost of being in that habitat, with low values indicating preferred and more suitable habitats and high values indicating non-suitable habitat or that which may pose the greatest threat to the species (for example roads, water, arable land or urban areas may be examples of 'costly' habitats depending on the species in question). These models assume that individual move to areas that are of low cost.

The data was collected from several areas in and around Oxford, UK. GIS maps of these areas were supplied from one of the authors (Frank Adriaensen at the University of Antwerp) but the rest of the analysis was done by attempting to re-implement the statistical analysis of a number of least-cost models as detailed in the Driezen paper.

12 models were generated, each providing a different set of values for the habitat types found within the study areas.

Hedgehog locations were recorded as data points and overlaid on the GIS maps.

By amending the attribute table of each GIS raster dataset, the cost of each habitat could be added to the GIS layer. ArcGIS has good functionality and so an in-built function to generate a cost layer was used to create the leats-cost model from the original habitat map.

Each hedghog was released from a fixed location and this was used as the reference point for analysis. As you can see below, concentric circles were generated using each release point as the centre and each observed location from the release point as the radius. The spatial analyst extension in ArcGIS was used to generate summary statistics for each circle, from which a comparison between cell costs could be made and a z-score calculated from which to perform some quite complicated statistical analyses (look to later posts for reference and discussion on stats etc).

Fig 1. Original habitat map showing one hedgehog path and concentric circles used to score each least-cost model, on the left. On the right, an example least-cost model with concentric circle. As the cost of the landscape increases the colour changes from brown (low cost) to blue(high cost). The path taken by the hedgehog is shown in red:








The cost of the cell in which the hedgehogs were located was then compared to the costs of all the other cells located on the edge of that same circle. If the observed location cell cost is lower then average then it means the hedgehog is located in a relatively lower cost habitat. The lower the cost, in comparison to the average cost per circle and per individual hedgehog, the better the least-cost model is in explaining how hedgehogs move around the landscape.


By doing this same analysis for all of the regions and all 22 hedgehogs for which we had data, one least-cost model produced the best fit to the data. (In this case it was resistance set 10).

My results were different to those found by the original Driezen study and least-cost models seem sensitive to selection of empirical datasets. However, the selection and generation of least-cost models to test seemed random and arbitrary and perhaps more thought and a a full sensitivity analysis may provide more confidence in the selection of the most suitable least-cost models.

next post: extension to this work: using least-cost modelling in a simplified agent-based simulation in Netlogo.

7.6.11

Summer Project 2010

My first exploration with agent-based simulations was, thanks to my good friend Melissa, via Netlogo: a free and really nice piece of software with a whole host of built in models for you to explore.

I had limited programming ability before starting at Southampton and some introductory model building during my first year with Matlab, Python and C# told me that I did not have enough experience as of yet to attempt to create my first ABM (agent-based model) in one of these languages. Netlogo is a lot easier to use than stand-alone languages, coming in a friendly GUI environment and lacking the usual 'grammer' and 'punctuation' of other more advanced languages. The package is built specifically for agent-based modelling and I found it quick, easy and straightforward to pick up.

If programming is not your strong point then I definitely recommend using Netlogo, at least to start with.

It was easy to get agents moving around the screen: Netlogo has a built in feature that automatically displays agents on the screen. You can add buttons, graphs and sliding scales to change model parameters, display certain bits of information and keep a running output of any agent characteristics that you may be interested in.

Check out the simple sheep-wolf model that comes as part of the Netlogo package. The link will open up the model in a standard web browser from where you can manipulate and run the model:



1. Click on setup. This will display the landscape, sheep and wolves in the display box on the right.
2. Clock on go. This will run the model and you should see the sheep and wolves moving around the display box.
3. Clock on go again to stop the simulation.
4. Note the graph of population size of both sheep and wolves at the bottom, changing over time as the simulation runs.
5. Change any of the settings and run the simulation again (remembering to click setup before you click on go).
6. You should not see a change in the graph at the bottom of the page that reflects the changes you made in the parameters.
7. Change the show-energy? and grass? buttons to on instead of off and these will now be displayed in the display box.
8. Its as easy as that!

Example:



When you download netlogo you are presented with a blank display console incorporating a blank display box on the right hand side. Clicking on file - models library, will open the list of available models that you can choose to run.

A really great feature, from having so many models included in the package, is that it is really easy to figure  out how to create models: simply look at the code that comes with any of the included models to figure things out. This is done via the procedures tab at the top of the netlogo console.

The Netlogo website has a lot of information on how to get started, notably via the User manual and the tutorials, which can be found here.



next post: my first netlogo model

6.6.11

About me

A bit more background about me so far.

I started my academic life at Royal Holloway, University of London where I completed a BSc in Zoology. I gained a first class honours degree and spent my second year at the University of Western Ontario, Canada, as part of the study abroad scheme: probably the best decision I have ever made. I made a lot of good friends and had a really amazing experience.

Following this I headed back to my home town of Cardiff and after a stint working in a bar, doing some volunteer work with the National Trust, and heading to South Africa to participate in a volunteer research programme at Edeni Game Reserve (via GVI), I started working for Defra at my local Animal Health Office.

Two years later I had had enough of working in an admin role, even if it was vaguely related to farming and hence conservation, so I applied to the University of Leeds for the master programme in Biodiversity and Conservation. Choosing the Master of Research (MRes) programme instead of the usual Master of Science (MSc) I did fewer taught courses with two full-length theses, instead of the usual one.

After a failed attempted for a PhD that, looking back on it, I probably only half wanted to do, I got a job with Natural England as a Senior Land Management and Conservation Adviser. Now this was more like it. Not only was I getting paid to learn about conservation and land/habitat management but I also got to spend half my working life walking around farms talking to farmers and looking for opportunities to enhance the wildlife on the farm. A pretty good job that also included some 'training' opportunities that took me on two week long trips learning about upland farming and grassland ecology, as well as other workshops looking at wet grasslands and farmland birds.

I learnt a hell of a lot at this job. Not only about wildlife, habitat management and farming but also about what I wanted to get out of my career and what I was willing to do to get it.

So, after nearly two years in a well paid and really great job, I quit!

Signal, the next step in my varied work life: the Institute for Complex Systems Simulation.



I applied for, and got offered a place on the four-year PhD programme at the University of Southampton. It was the first year they had run the programme and I, along with 20 others, became the Southampton Complexity Science guinea pigs. As part of a Doctoral Training Centre, it is a four-year PhD programme with a taught year equivalent to a masters followed by a three-year research programme.

There are only three universities in the UK with research specifically related to complex systems; Southampton, Bristol and Warwick. Of course, the course at Southampton is the best :)

Pages devoted to the research that goes on as part of this programme, encompassing a wide range of departments and academics can be found here, on the Computational Modelling Group website.

So, after doing some pointless and dreary jobs, and having a sporadic education, I am finally on the way to getting that all important PhD!

Next post: my PhD research so far.

3.6.11

Hello and Welcome

This is my first post on this new blogging site, so hello!

To introduce myself, my name is Angela Watkins. I am currently in the second year of a four-year PhD programme with the University of Southampton within the Institute of Complex Systems Simulation. I sit jointly within the School of Biological Sciences and the School of Electronics and Computer Science.

My research aims to look at the effect of habitat fragmentation and corridor design on the permeability of habitat for jaguars within the Central Belize Corridor. This research links into ongoing work assessing the functionality of the corridor area for a range of local wildlife, see Belize Wildlife Research, as part of the Jaguar Corridor Initiative.

I have done some preliminary work on designing and building agent-based simulations of jaguar movements in some simple and abstract landscapes, with some promising results. My next step is to integrate these simulations with some real GIS (Geographic Information System) data in order to validate and tune jaguar movements to existing data obtained from camera-trap studies.

This blog will aim to chart my progress and hopefully provide some useful information to others working in the same field.

Feel free to contact me with any questions or suggestions.