Skip to content

RoadTrafficModel_step5

RoiArthurB edited this page Feb 27, 2024 · 2 revisions

5. Dynamic weights

This 5th step illustrates how to obtain the shortest path from a point to another one and to update the weights of an existing graph.

Formulation

  • At initialization, the value of the destruction_coeff of the road agents will be equal to 1.
  • Add a new parameter: the destroy parameter that represents the value of destruction when a people agent takes a road. By default, it is equal to 0.02.
  • When a people agent arrive at its destination (home or work), it updates the destruction_coeff of the road agents it took to reach its destination: "destruction_coeff = destruction_coeff - destroy". Then, the graph is updated.

Model Definition

global section

We add the destroy parameter.

In the global section, we define the destroy variable:

float destroy <- 0.02;

In the experiment section, we add a parameter:

parameter "Value of destruction when a people agent takes a road" var: destroy category: "Road" ;

We define a new reflex that updates the graph at each simulation step. For that, we use the with_weights operator. This operator allows to update the weights of an existing graph.

global {
    ...
    reflex update_graph{
        map<road,float> weights_map <- road as_map (each:: (each.destruction_coeff * each.shape.perimeter));
        the_graph <- the_graph with_weights weights_map;
     }
}

people agents

At each time-step, after a people agent has moved over one or multiple road segments, it updates the value of the destruction coefficient of road agents crossed (i.e. roads belonging to the path followed). We have for that to set the argument return_path to true in the goto action to obtain the path followed, then to compute the list of agents concerned by this path with the operator agent_from_geometry.

species people skills: [moving]{
    ...
    reflex move when: the_target != nil {
	path path_followed <- goto(target: the_target, on:the_graph, return_path: true);
	list<geometry> segments <- path_followed.segments;
	loop line over: segments {
	    float dist <- line.perimeter;
	    ask road(path_followed agent_from_geometry line) { 
		destruction_coeff <- destruction_coeff + (destroy * dist / shape.perimeter);
	    }
	}
	if the_target = location {
	    the_target <- nil ;
	}
    }
    ...
}	

Complete Model

https://github.com/gama-platform/gama.old/blob/GAMA_1.9.2/msi.gama.models/models/Tutorials/Road%20Traffic/models/Model%2005.gaml
  1. What's new (Changelog)
  1. Installation and Launching
    1. Installation
    2. Launching GAMA
    3. Updating GAMA
    4. Installing Plugins
  2. Workspace, Projects and Models
    1. Navigating in the Workspace
    2. Changing Workspace
    3. Importing Models
  3. Editing Models
    1. GAML Editor (Generalities)
    2. GAML Editor Tools
    3. Validation of Models
  4. Running Experiments
    1. Launching Experiments
    2. Experiments User interface
    3. Controls of experiments
    4. Parameters view
    5. Inspectors and monitors
    6. Displays
    7. Batch Specific UI
    8. Errors View
  5. Running Headless
    1. Headless Batch
    2. Headless Server
    3. Headless Legacy
  6. Preferences
  7. Troubleshooting
  1. Introduction
    1. Start with GAML
    2. Organization of a Model
    3. Basic programming concepts in GAML
  2. Manipulate basic Species
  3. Global Species
    1. Regular Species
    2. Defining Actions and Behaviors
    3. Interaction between Agents
    4. Attaching Skills
    5. Inheritance
  4. Defining Advanced Species
    1. Grid Species
    2. Graph Species
    3. Mirror Species
    4. Multi-Level Architecture
  5. Defining GUI Experiment
    1. Defining Parameters
    2. Defining Displays Generalities
    3. Defining 3D Displays
    4. Defining Charts
    5. Defining Monitors and Inspectors
    6. Defining Export files
    7. Defining User Interaction
  6. Exploring Models
    1. Run Several Simulations
    2. Batch Experiments
    3. Exploration Methods
  7. Optimizing Models
    1. Runtime Concepts
    2. Analyzing code performance
    3. Optimizing Models
  8. Multi-Paradigm Modeling
    1. Control Architecture
    2. Defining Differential Equations
  1. Manipulate OSM Data
  2. Cleaning OSM Data
  3. Diffusion
  4. Using Database
  5. Using FIPA ACL
  6. Using BDI with BEN
  7. Using Driving Skill
  8. Manipulate dates
  9. Manipulate lights
  10. Using comodel
  11. Save and restore Simulations
  12. Using network
  13. Headless mode
  14. Using Headless
  15. Writing Unit Tests
  16. Ensure model's reproducibility
  17. Going further with extensions
    1. Calling R
    2. Using Graphical Editor
    3. Using Git from GAMA
  1. Built-in Species
  2. Built-in Skills
  3. Built-in Architecture
  4. Statements
  5. Data Type
  6. File Type
  7. Expressions
    1. Literals
    2. Units and Constants
    3. Pseudo Variables
    4. Variables And Attributes
    5. Operators [A-A]
    6. Operators [B-C]
    7. Operators [D-H]
    8. Operators [I-M]
    9. Operators [N-R]
    10. Operators [S-Z]
  8. Exhaustive list of GAMA Keywords
  1. Installing the GIT version
  2. Developing Extensions
    1. Developing Plugins
    2. Developing Skills
    3. Developing Statements
    4. Developing Operators
    5. Developing Types
    6. Developing Species
    7. Developing Control Architectures
    8. Index of annotations
  3. Introduction to GAMA Java API
    1. Architecture of GAMA
    2. IScope
  4. Using GAMA flags
  5. Creating a release of GAMA
  6. Documentation generation

  1. Predator Prey
  2. Road Traffic
  3. 3D Tutorial
  4. Incremental Model
  5. Luneray's flu
  6. BDI Agents

  1. Team
  2. Projects using GAMA
  3. Scientific References
  4. Training Sessions

Resources

  1. Videos
  2. Conferences
  3. Code Examples
  4. Pedagogical materials
Clone this wiki locally