Showing posts with label ABM Platforms. Show all posts
Showing posts with label ABM Platforms. Show all posts

Saturday, April 29, 2023

GAMA: (Gis & Agent-based Modelling Architecture) Platform

Reader of the blog know we use predominantly MASON, NetLogo and MESA for our modeling projects but there are others (which we have discussed in other posts). To this end, recently over on the SIMSOC@JISCMAIL.AC.UK mailing list, Alexis Drogoul announced the release of GAMA 1.9.1 and if the YouTube movie of the release is anything to go by it looks really interesting. More information about GAMA can be seen on their project page: https://gama-platform.org/

On a side note, if you are interested in using  computer simulation in the social sciences the SIMSOC mailing list is worth signing up for.

Tuesday, November 01, 2022

Mesa-Geo: ABM and GIS in Python (A Update)

A couple of months ago we had a post about Mesa-Geo but only a short one. Now we want to go into more detail as we (Boyu Wang, Vincent Hess and myself) just presented a paper about it at the 5th ACM SIGSPATIAL International Workshop on Geospatial Simulation (GeoSim 2022). The paper itself was entitled "Mesa-Geo: A GIS Extension for the Mesa Agent-Based Modeling Framework in Python" in which we discuss in detail the need for a python library for creating geographically explicit agents (or GeoAgents) and introduce its architecture. 

In the paper we detail how we have designed Mesa-Geo to handle spatial data (both in terms of raster and vector via GeoSpace), how we have enabled visualization of geographical data and such models along with creating features to export geographical data from the simulations (using Rasterio and GeoPandas). To support this discussion we also provide some explicit examples on how the pieces fit together  range from rainfall flowing over a digital terrain model (DEM) to Schelling types of models using points and polygons as agents, to that of agents using road networks to navigate over an area. Boyu has also put together more details about the examples at: https://mesa-geo.readthedocs.io/en/latest/examples/overview.html (which includes movies of them running).  The actual code for the models and Mesa-Geo can be found at https://github.com/projectmesa/mesa-geo. Just to give you a sense of the paper and what Mesa-Geo can do, below we provide the abstract to the paper, some figures showing the architecture, along with some example applications. While at the bottom of the post you can see the full reference and a link to the paper itself.  

 

Abstract: Mesa is an open-source agent-based modeling (ABM) framework implemented in the Python programming language, allowing users to build and visualize agent-based models. It has been used in a diverse range of application areas over the years ranging from biology to workforce dynamics. However, there has been no direct support for integrating geographical data from geographical information systems (GIS) into models created with Mesa. Users have had to rely on their own implementations to meet such needs. In this paper we present Mesa-Geo, a GIS extension for Mesa, which allows users to import, manipulate, visualize and export geographical data for ABM. We introduce the main components and functionalities of Mesa-Geo, followed by example applications utilizing geographical data which demonstrates Mesa-Geo's core functionalities and features common to agent-based models. Finally, we conclude with a discussion and outlook on future directions for Mesa-Geo.

Class diagram of the Agent, GeoAgent, and Cell classes
Component diagram of GeoSpace and its related classes
Example applications using Mesa and Mesa-Geo: (a) Rainfall model, (b) Population model, (c) GeoSchelling (polygons) model, (d) GeoSchelling (points \& polygons) model, and (e) Agents and networks model.


 If you have any thoughts or comments about Mesa-Geo please let us know.

Full reference:

Wang, B., Hess, V. and Crooks A.T. (2022), Mesa-Geo: A GIS Extension for the Mesa Agent-Based Modeling Framework in Python, Proceedings of the 5th ACM SIGSPATIAL International Workshop on Geospatial Simulation (GeoSim 2022), Seattle, WA. pp 1-10. (PDF)

Wednesday, August 31, 2022

Mesa-Geo: ABM and GIS in Python

In the past I have blogged a lot on creating geographically explicit models in NetLogo, Repast and Mason but not so much about models created in Python. Even though Python is growing in popularity and their exists an agent-based modeling framework in Python called Mesa (click here to see a paper on this). But this lack of blogging about geographically explicit agent-based models will be changing as I have been recently working with Boyu Wang (a PhD student here at UB) who together with others have been developing Mesa-Geo. To give you as sense of Mesa-Geo, below are some example models that can be downloaded from https://github.com/projectmesa/mesa-geo or https://github.com/wang-boyu/agents-and-networks-in-python. These models range from rainfall flowing over a digital terrain model to Schelling types of models using points  and polygons as agents, to that of agents using road networks to navigate over an area.  In a future post we will go into more details but if you are interested in creating geographically explicit agent-based models in Python please check out the repositories.

 Mesa-Geo example models: (a) Rainfall, (b) Population, (c) Schelling (polygons) , (d) Schelling (points & polygons), and (e) Agents and networks.

Thursday, October 15, 2020

Utilizing Python for Agent-based Modeling: The Mesa Framework

In the past I have mentioned Mesa, an agent-based modeling framework in Python is several posts but not really discussed it in detail. This is about to change with this post. The reason being is that we have a paper at the forthcoming International Conference on Social Computing, Behavioral-Cultural Modeling and Prediction and Behavior Representation in Modeling and Simulation (or SBP-BRiMS for short) entitled "Utilizing Python for Agent-based Modeling: The Mesa Framework".

While Mesa started off with two students from the CSS program at George Mason University: Jackie Kazil and David Masad it has now grown to include over 70 contributors. In this new paper we discuss the rationale for developing Mesa (see https://github.com/projectmesa/mesa) which arose because there was no framework for easily building agent-based models in Python. Furthermore we discuss Mesa's design goals and its architecture and usage, along with who is using Mesa and extensions to it (e.g. Mesa-Geo, Multi-Level Mesa), finally we conclude the paper with future development directions. Below we provide the abstract to the paper and a selection of figures which highlights Mesa's model components (model, analysis and visualization), how various activation schedules are incorporated within Mesa and an illustration of how these different schemes impact a model and some examples of Mesa's visualization functionality. At the bottom of the post we have the full reference and a link to the paper.

Abstract.
Mesa is an agent-based modeling framework written in Python. Originally started in 2013, it was created to be the go-to tool in for re-searchers wishing to build agent-based models with Python. Within this paper we present Mesa’s design goals, along with its underlying architecture. This includes its core components: 1) the model (Model, Agent, Schedule, and Space), 2) analysis (Data Collector and Batch Runner) and the visualization (Visualization Server and Visualization Browser Page). We then discuss how agent-based models can be created in Mesa. This is followed by a discussion of applications and extensions by other researchers to demonstrate how Mesa design is decoupled and extensible and thus creating the opportunity for a larger decentralized ecosystem of packages that people can share and reuse for their own needs. Finally, the paper concludes with a summary and discussion of future development areas for Mesa. 

Keywords: Agent-based Modeling, Python, Framework, Complex Systems. 
Mesa model components: model, analysis and visualization.
Activation schedules within Mesa and an illustration of how these different schemes impact a model. In this case the Prisoner’s Dilemma. Defecting agents are in red and cooperating agents are in blue. Each image is from the same step, but different activation schemes are used.
Model visualization of two Mesa applications within a web browser: (A) Wolf-sheep predation Model. (B) Virus on a network (Source: https://github.com/projectmesa).

Full Reference: 
Kazil, J., Masad, D. and Crooks, A.T. (2020), Utilizing Python for Agent-based Modeling: The Mesa Framework, in Thomson, R., Bisgin, H., Dancy, C., Hyder, A. and Hussain, M. (eds), 2020 International Conference on Social Computing, Behavioral-Cultural Modeling & Prediction and Behavior Representation in Modeling and Simulation, Washington DC., pp. 308-317. (pdf)

Friday, October 19, 2018

New Paper: Scalability in the MASON Multi-agent Simulation System

Previously we posted about our work on advancing MASON, part of which we briefly discussed making it distributed in order to  run large scale models including geographical explicit ones along for optimization and validation purposes. To this end we recently had a paper accepted and presented at the  22nd International Symposium on Distributed Simulation and Real Time Applications (DS-RT 2018),  entitled "Scalability in the MASON Multi-agent Simulation System". 

In this paper we describe a distributed version of the MASON, and use three existing MASON models: HeatBugs, Flockers, and CampusWorld, to demonstrate how Distributed MASON achieves highly scalable performance, in terms of linear performance increases as the size of the simulations grow using Amazon Web Services.  Below you can read the abstract of the paper, see  some figures relating to how we go about data management and some of the results. Finally, at the bottom of the post you can see the full reference and access the paper itself.

Abstract:
This paper describes Distributed MASON, a distributed version of the MASON agent-based simulation tool. Distributed MASON is architected to take advantage of well known principles from Parallel and Discrete Event Simulation, such as the use of Logical Processes (LP) as a method for obtaining scalable and high performing simulation systems. We first explain data management and sharing between LPs and describe our approach to load balancing. We then present both a local greedy approach and a global hierarchical approach. Finally, we present the results of our implementation of Distributed MASON on an instance in the Amazon Cloud, using several standard multi-agent models. The results indicate that our design is highly scalable and achieves our expected levels of speed-up.




Full Reference:
Wang, H., Wei, E., Simon, R., Luke, S., Crooks, A.T., Freelan, D. and Spagnuolo, C.  (2018), Scalability in the MASON multi-agent simulation system, in Besada, E., Polo, Ó.R., De Grande, R. and Risco J.L (eds.). Proceedings of the 22nd International Symposium on Distributed Simulation and Real Time Applications, Madrid, Spain, pp. 135-144. (pdf)

This research is supported by the National Science Foundation (Grant 1727303).

Monday, September 18, 2017

Agent-Based Modeling Chapter

In the recently published "Comprehensive Geographic Information Systems" edited by Bo Huang, Alison Heppenstall, Nick Malleson and myself have a chapter entitled "Agent-based Modelling"1. Within the chapter, we provide a overview of agent-based modeling (ABM) especially for the geographical sciences. This includes a section on how ABM emerged i.e. "The Rise of the (Automated) Machines", along with a discussion on what constitutes an agent. This is followed with steps to building an agent-based model, including: 1) the preparation and design; 2) model implementation 3) and how one goes about evaluating a model (i.e. verification, calibration and validation and how these are particularity challenging with respect to spatial agent-based models). We then discuss how we can integrate space and GIS into agent-based models and review a number of open-source ABM toolkits (e.g. GAMA, MASON, NetLogo) before concluding with challenges and opportunities that we see ahead of us, such as adding more complex behaviors to agent-based models, and how "big data" offers new avenues for multiscale calibration and validation of agent-based models.  If you are still reading this, below you can read the abstract of the paper and find the full reference to the chapter.

Abstract:
Agent-based modeling (ABM) is a technique that allows us to explore how the interactions of heterogeneous individuals impact on the wider behavior of social/spatial systems. In this article, we introduce ABM and its utility for studying geographical systems. We discuss how agent-based models have evolved over the last 20 years and situate the discipline within the broader arena of geographical modeling. The main properties of ABM are introduced and we discuss how models are capable of capturing and incorporating human behavior. We then discuss the steps taken in building an agent-based model and the issues of verification and validation of such models. As the focus of the article is on ABM of geographical systems, we then discuss the need for integrating geographical information into models and techniques and toolkits that allow for such integration. Once the core concepts and techniques of creating agent-based models have been introduced, we then discuss a wide range of applications of agent-based models for exploring various aspects of geographical systems. We conclude the article by outlining challenges and opportunities of ABM in understanding geographical systems and human behavior.

Keywords: Agent-based modeling; Calibration; Complexity; Geographical information science; Modeling and simulation; Validation; Verification.





Full Reference
Crooks, A.T., Heppenstall, A. and Malleson, N. (2018), Agent-based Modelling, in Huang, B. (ed), Comprehensive Geographic Information Systems, Elsevier, Oxford, England. Volume 1, pp. 218-243 DOI: https://doi.org/10.1016/B978-0-12-409548-9.09704-9. (pdf)

1. [Readers of this blog might of expected the chapter would be about Agent-based Modeling, but its still worth a read!]

Friday, September 25, 2015

Mesa: An Agent-Based Modeling Framework in Python

Just a short post to say two of our PhD students, David Masad and Jackie Kazil have been developing an agent-based modeling framework in Python called Mesa.

To quote from David's talk abstract:
"Agent-based modeling is currently a hole in in Python’s robust and growing scientific ecosystem. Mesa is a new open-source package meant to fill that gap. It allows users to quickly create agent-based models using built-in core components (such as agent schedulers and spatial grids) or customized implementations; visualize them using an innovative browser-based interface; and analyze their results using Python’s robust data analysis tools. Its goal is to be a Python 3-based alternative to other popular frameworks based in other languages such as NetLogo, Repast, or MASON."

Below is short presentation outlining Mesa from SciPy 2015:


Thursday, January 23, 2014

Agentscript: ABM Framework

http://www.geotalisman.org/2013/12/18/bugs-on-a-map/
In the past I have blogged (and even written papers) about agent-based modeling toolkits / frameworks such as MASON, Repast and NetLogo for the creation of models. One issue is the deployment of models over the internet. Thanks to Richard Milton from the TALISMAN blog for pointing out agentscript. Agentscript is billed as "a minimalist Agent Based Modeling (ABM) framework based on NetLogo agent semantics. Its goal is to promote the Agent Oriented Programming model in a highly deployable CoffeeScript/JavaScript implementation." The image on the left shows a simple agentscript model on Google Maps from Richard. The agentscript website also has several examples which shows it potential for the creation for geospatial agent-based models which can be deployed within a website. For example, below  agents (blue) seek and move to the lowest elevation.

http://agentscript.org/models/droplets.html



Wednesday, March 13, 2013

GAMA (Gis & Agent-based Modelling Architecture) Platform

While I have blogged about creating geographically explicit agent-based models with Repast, MASON, NetLogo and several other toolkits before, I recently came across an open source toolkit called Gis & Agent-based Modelling Architecture or GAMA for short. GAMA is developed by UMMISCO and to quote from the site:
"GAMA is a simulation platform, which aims at providing field experts, modelers, and computer scientists with a complete modeling and simulation development environment for building spatially explicit agent-based simulations." 
The site offers a series of tutorials, supporting documents and publications which show the potential of GAMA. The movie below gives an excellent overview of what GAMA can do. 



Tuesday, January 29, 2013

Agent-based modeling in ArcGIS

Anyone who is heavy user of ArcGIS and wants to explore how to create agent-based models within it should check out the new Agent-Analyst  book from ESRI. 

After skimming through the chapters it looks like a great resource for teachers or individuals wishing to create geographically explicit agent-based models. There are a number of step-by-step exercises which show you how one can use points, polygons and rasters to create agent-based models. Also there is a discussion on how to create agents with simple behaviors.

More information including the book, software and data can be downloaded from http://resources.arcgis.com/en/help/agent-analyst/ 


Thursday, May 31, 2012

Diseases and Refugee camps

Dadaab refugee camp
One of the projects we are working on at GMU is exploring the the dynamics of refugee camps and the spread of diseases within such camps. 

Our initial focus is on the the Dadaab refugee camps which are located in Kenya, approximately 100 kilometers from the Somali border. The camps themselves are homes to roughly 500,000 people, with nearly 99% of the population coming from Somalia. Within the camps the mortality rate is ~ 0.44/10,000 per day with  diseases such as cholera and measles being among the causes of death.

Below are some movies of the prototype models that are currently being developed in Mason ABM toolkit and utilizing its GeoMason extension. The first movie shows a overview of the model dashboard, while the second show the spread of cholera within the area.





While the second movies (below) shows our first attempt at modeling one type of disease, that of cholera. In the simulation we pollute one bore hole with cholera and simulated how it might spread through the camp under specific conditions.




While this is still work in progress, we thought it worth sharing to see what feedback we may get. More details about the models will come soon.

Click here to see previous blog posts on diseases


Wednesday, March 14, 2012

Distributed MASON


Last week, the Center for Social Complexity at GMU, hosted Prof. Vittorio Scarano and Carmine Spagnuolo from the ISISLab of the Università degli Studi di Salerno who have been working on a distributed version of MASON (DMason). The idea is that one can create an agent-based model in MASON and then use the framework to easily distribute it over many machines. The movie below shows an example of what can be done. More information can be found here.




However, if you don't use MASON, you might also be interested in Repast for High Performance Computing

Friday, April 29, 2011

Using agents to explore traffic: Part Two-Micro to Macro

Following on from a previous post on traffic modeling with agent-based models, I have been thinking of other work in this area and came across the following movies on Youtube. The first is a traffic simulator from Martin Treiber. What is interesting is the "coffeemeter" that gives an impression of the accelerations and jerks in the traffic. You can investigate this model further here: http://www.traffic-simulation.de/ or watch the movie below.




The question you might be asking in yourselves is, do such models work in reality? The mathematical theory behind these so-called "shockwave" jams was developed more than 15 years ago using models that show jams appear from nowhere on roads carrying their maximum capacity of free-flowing traffic – typically triggered by a single driver slowing down. Below is a movie of the NetLogo Traffic Basic Model exploring this principle.


Hopefully the movie above helps add something to your question. But if not check out the next movie (make sure the sound is on). In which a team of Japanese researchers recreated the phenomenon on a test-track by putting 22 vehicles on a 230-meter single-lane circuit. Drivers were asked to cruise steadily at 30 kilometers per hour, and at first the traffic moved freely. But small fluctuations soon appeared in distances between cars, breaking down the free flow, until finally a cluster of several vehicles was forced to stop completely for a moment. That cluster spread backwards through the traffic like a shockwave. Every time a vehicle at the front of the cluster was able to escape at up to 40 km/h, another vehicle joined the back of the jam. The full article can be read in New Scientist (click here).


Moving away from traffic jams, as the previous post highlighted we can also use agent-based models to look at traffic intersections. The movie shows a more complicated intersection than in the last post and shows how different intersections can be visualized and modeled.



But while the above movie is rather simplistic, agent-based models can be developed from such simple situations to more complex one. For example, if you can model one type of intersection what is stopping you for modeling more? The movie below shows a more complex set of intersections using Paramics (however, this is noted to be a microsimulation model, if you are interested in finding out the difference between microsimulation and ABM see here).



From a local scene we can also turn to exploring more larger scenes such as entire metropolitan regions. The movie below is of that of TRANSIMS microsimulation-agent based model applied to downtown Chicago:



What I find so interesting about such traffic models is how one can go from basic models at the micro level and scale up such models (and of adding more complexity) to explore more macro phenomena such as traffic jams at metropolitan scales.

Monday, January 31, 2011

Urban Growth and Change


As many of us know more people are now living in cities than ever before. Over half (3.3 billion people) of the world’s population are located in urban areas and this proportion is predicted to increase to over 75 percent by the year 2100 (United Nations, 2007). What I find most interesting is that while cities are growing they are also constantly changing.

The reason I bring this up are twofold. First I recently stumbled upon a site from the NY Times entitled "Mapping America: Every City, Every Block" which shows data from the US Census Bureau's American Community Survey from 2005 to 2009. What is interesting is that there are several maps showing the distribution of racial and ethnic groups throughout the US along with the percentage of foreign born and how neighborhood have changed over time (similar work is also being done at CASA for the UK's population). Such data could come in handy for residential segregation models.

Secondly, as cities grow, the question is where will such growth occur or in some instances where will urban areas decline (e.g. urban shrinkage). Recently we started using GeoMason to explore urban growth using the SLEUTH model as our basis. In the movie below we explore a simple growth scenario around Santa Fe, New Mexico. The model, like the original has the 5 growth coefficients (Dispersion, Breed Spread, Slope, Road) which affect how the growth rules are applied. We also implement the same growth rules (that of Spontaneous Growth, New Spreading Centers, Edge Growth,Road-Influenced Growth) as described on the SLEUTH website. The only thing missing from the model is the self modification procedures during the run time of the model. Data for the model comes a variety of sources including the National Map, the New Mexico Atlas and ESRI.

Thursday, December 30, 2010

GeoMason: Geospatial Support for MASON

MASON (Multi-Agent Simulator Of Neighborhoods) developed jointly at George Mason University's Evolutionary Computation Laboratory and the Center for Social Complexity has recently added an extension called GeoMason which allows spatially explicit models to be incorporated into the MASON.

Over the last few months I have been experimenting with GeoMason in terms of using both raster and vector data to build spatially explicit agent-based models. Overall, I have been impressed by the speed of which such models run at and the example models that come with it GeoMason are really useful.

Below are some of the test models we have developed for a course on entitled GIS and Agent-based modeling which was taught in the Department of Computational Social Science at GMU.

The first model is based on importing a geotiff of the National Elevation Dataset at 1 arc second from the National Map of Crater Lake, Oregon. After which water is added (which could be considered loosely as agents) and flows from high to low elevations, if the water can not flow over the surface it pools. As the movie below shows, over time, Crater Lake slowly fills up until the water breaches the caldera rim which allows the water to flow out. This model was inspired by the NetLogo Grand Canyon Model.


Moving towards vector data, below is a simple example of using GeoMason for a spatially explicit Schelling style of model of segregation where neighborhoods are not based on a regular square lattice but on irregular cells and in this case stylized on Washington DC. The model uses polygon boundaries of census tracks from the 2000 US census. In the model, each census track knows which other census tracts are its neighbors and only one agent occupies such a track. As in the normal Schelling styles of models, agents want to be located in neighborhoods where a certain percentage of their neighbors are of the same type. If an agent is dissatisfied with its neighborhood it moves to a new location. This movement causes more movement and the result is that areas become segregated.



The next movie, highlights a variant of the Schelling model. Whereby we take aggregate data and use this to populate the model with agents. The reason for this is that much of the data we have comes at an aggregate level and often in some sort of vector representation of space such as census data. However, if we want to model the individuals or groups of individuals we can take this data along with other information and use it as a basis of spatially explicit agent-based model. Basically, this model extends the polygon model above and creates agents based on attribute data held within the shapefile. While the model is highly stylized it demonstrates how data can be read into the model, how to create agents based on this data and how to link points (agents) to polygons along with some basic geographical operations (such as union, point in polygon, buffer).


To download GeoMason click here (note there a number of model examples here). For more information on GeoMason there is a technical report:

Sullivan, K., Coletti, M. and Luke, S. (2010), GeoMason: GeoSpatial Support for MASON, Department of Computer Science, George Mason University, Technical Report Series, Fairfax, VA.

Also when I have time I will provide more details on the models above and others using GeoMason.

Thursday, June 17, 2010

GMU Fiarfax Campus created with CityScape

I have just been exploring the demo version of CityScape from PixelActive and I am quite impressed. CityScape is an urban modeling tool that allows users to build both custom and real-world environments quickly and easily. The focus of the modeler is on allowing developers to concentrate on design rather than the labor involved in creation.

The movie below show my initial attempt of creating a agent-based traffic model around the Fairfax Campus of George Mason University. The model utilizes a real world elevation data downloaded from the U.S. Geological Survey's (USGS) National Map, the road data comes from OpenStreetMap and the building footprints from the Geospatial Data Collection at Mason.



Some readers might find the movie below from an earlier post created in Repast Simphony an interesting comparison. Basically in this model, agents are pedestrians and they choose the shortest route between two buildings.


Thursday, May 20, 2010

Cormas and ComMod

Following on from the UVA Bay Game post I thought it was about time to blog about Cormas and the ComMod (Companion Modeling Approach) which focus on participatory agent-based modeling for resource management.

Why the interest? Take ecosystem management as an example, there are often many actors (stakeholders) who influence and control ecosystem management. For example, in the Chesapeake Bay there are farmers, local policy-makers, watermen, and developers. Such stakeholders have many different goals, associated feedbacks, negotiations etc... The question is how does one build models of such interactions?

Often when we build models of such interactions we do not always engage with stakeholders directly. Participatory modeling approaches such as companion modeling offers one way for such engagement. It uses various techniques, including role playing games in the sense that models are built with the direct involvement of stakeholders. Where modelers develop and validate model rules in conjunction with those one is modeling. Such a direct involvement of stakeholders focuses our attention on how decisions are made and what are the problems rather than just simulating the effects (e.g. Gimblett et al., 2002).

This brings me back to the ComMod approach and Cormas (an agent-based simulation framework, often used in conjunction with the ComMod approach). In the sense that ComMod is a iterative modeling process from the “bottom up.” ComMod provides an endless cycle of "field work and data analysis -> role playing games -> agent-based model development and implementation -> simulation -> field work again (Barreteau, 2003) as depicted below:

Some references for further reading:
  • Barreteau, F.O. and others (2003), 'Our Companion Modelling Approach', Journal of Artificial Societies and Social Simulation, 6(1), Available at http://jasss.soc.surrey.ac.uk/6/2/1.html.
  • Etienne, M. (2003), 'SYLVOPAST: A Multiple Target Role-Playing Game to Assess Negotiation Processes in Sylvopastoral Management Planning', Journal of Artificial Societies and Social Simulation, 6(2), Available at http://jasss.soc.surrey.ac.uk/6/2/5.html.
  • Gilbert, N., Maltby, S. and Asakawa, T. (2002), 'Participatory Simulations for Developing Scenarios in Environmental Resource Management', in Urban, C. (ed.), Third Workshop on Agent-Based Simulation, SCS European Publishing House, Passau, Germany, pp. 67-72.
  • Ramanath, A.M. and Gilbert, N. (2004), 'The Design of Participatory Agent-Based Social Simulations', Journal of Artificial Societies and Social Simulation, 7(4), Available at http://jasss.soc.surrey.ac.uk/7/4/1.html.

To see some Cormas examples (Click here). Click here to see the ComMod program at work and here for the ComMod site. While the movie below shows one application of Cormas:


Monday, January 04, 2010

modelling4All update

I been following the progress of modelling4All for a while now and thought it worth highlighting again (click here to see an earlier post), especially after a post on the modelling4All blog noting some improvements.

The aim of modelling4All is to reduce the difficulty and effort needed to make agent-based models therefore enabling non-programmers to collaboratively build and analyze computer models. modelling4All allows one to create agent-based models over the web, models are constructed by composing and parametizing model fragments (bits of code) as shown in the movie below.



The model fragment library can be searched and model fragments can be added and combined to a model to create an agent-based model in a very short period of time by just clicking on the fragment (such as a behavior) which is required for the task at hand. Click here to see such a model, in this case its an epidemic model where people go to work, school, and home. A neat feature is also the ability to export the models as NetLogo models.

Thursday, November 05, 2009

TourSim: Agent-based modeling for Tourism Planning

While reading the 7.5th Floor blog, I cam across an interesting post about the use of agent-based modeling for tourism/recreational planning. The post talks about the TourSim model developed by Peter Johnson. The model is created using AnyLogic and explores tourists visiting Nova Scotia and the destinations they visit under different scenarios. Peter provides a tutorial about using the model along with data sources used in creating and verifying this model. As with many other AnyLogic models (click here to see some demos), not only is it highly visual but can be run in a web browser. Further details about TourSim can be found here.

Sunday, August 09, 2009

Partitioning Space to generate urban spatial patterns.

Fraser Morgan and David O'Sullivan have recently written a paper entitled "Using binary space partitioning to generate urban spatial patterns" which was presented at the 4th International Conference on Computers in Urban Planning and Urban Management (CUPUM).

The abstract of their paper is:

Creating a realistic representation of urban spatial patterns is often problematic. Using existing development as a starting point for testing models of urban growth may introduce inherent biases based on the city chosen. To address this issue, we have used binary space partitioning (BSP) trees to quickly generate a representation of the cadastral spatial pattern seen in cities. This approach, which has links to quadtrees and binary trees used in computer science, includes the standard topologic elements (leaf nodes, children, root node, ancestors, descendants and levels) while also incorporating the spatial element of territory. The substantial flexibility in the resulting urban structure belies the small number of parameters used to control the creation of the tree.

This BSP tree approach was developed to create many similar and realistic urban spatial patterns on which an agent-based model of the purchase, subdivision, building and disposal behaviours of property developers would operate. The motivation for implementing a BSP tree approach was the ability for the developer agents to be able to understand, analyse and enact the mechanism of subdivision upon the urban environment. Through the formalised node structure, the BSP tree approach also enables the straight forward implementation of developer territoriality, neighbourhood attractiveness and spatial metrics for analysis."

Click here to read the full paper which is very interesting. To accompany the paper there is also a NetLogo model is just a small aspect of the wider ABM model that Fraser is working on which provides an interesting representation of an random urban cadastral pattern upon which the ABM does its work.