Outputs

Calculate mean

Sure, let’s break down and explain your NetLogo code step-by-step. I’ve added comments to help you remember the purpose and functionality of each part.

globals [priceA alpha-globals-rich alpha-globals-poor]

turtles-own [income rich alpha QA]

to setup
  clear-all  ; Clears the world, removing all turtles and resetting plots
  create-turtles 100 [
    setxy random-xcor random-ycor  ; Places each turtle at a random position
    set income random-normal 100 10  ; Assigns each turtle an income from a normal distribution with a mean of 100 and a standard deviation of 10
    if income > 50 [set rich true]  ; Classifies turtles as 'rich' if income is greater than 50
    if rich = true [
      set alpha random-normal 0.1 0.01  ; Assigns a normally distributed alpha to 'rich' turtles with mean 0.1 and std dev 0.01
    ]
    if rich = false [
      set alpha random-normal 0.2 0.02  ; Assigns a normally distributed alpha to 'poor' turtles with mean 0.2 and std dev 0.02
    ]
  ]
  reset-ticks  ; Resets the simulation clock
end

to go
  ask turtles [
    fd 1  ; Moves turtles forward by 1 unit
    rt random 90  ; Turns turtles right by a random angle between 0 and 90 degrees
    lt random 45  ; Turns turtles left by a random angle between 0 and 45 degrees
    compute  ; Calls the compute procedure for each turtle
  ]
  report-values  ; Calls the procedure to display the mean alphas
  tick  ; Advances the simulation clock by one tick
end

to compute
  ; Calculates the mean alpha for 'rich' turtles and assigns to global variable
  ifelse rich = true [
    set alpha-globals-rich mean [alpha] of turtles with [rich = true]
  ] [
    ; Calculates the mean alpha for 'poor' turtles and assigns to global variable
    set alpha-globals-poor mean [alpha] of turtles with [rich = false]
  ]
end

to report-values
  show alpha-globals-rich  ; Displays the mean alpha for rich turtles in the Command Center
  show alpha-globals-poor  ; Displays the mean alpha for poor turtles in the Command Center
end

Key Explanations:

• Globals and Turtles-own:
  • Globals: priceA, alpha-globals-rich, and alpha-globals-poor are variables accessible to all agents and procedures.
  • Turtles-own: income, rich, alpha, and QA are attributes specific to each turtle.
• Setup Procedure:
  • Initializes the environment by creating 100 turtles.
  • Each turtle is assigned a random income, the ‘rich’ status is determined, and an alpha value is set based on this status.
• Go Procedure:
  • Moves each turtle forward and changes its direction randomly.
  • Calls the compute procedure to calculate mean alpha values for rich and poor turtles.
• Compute Procedure:
  • Calculates and updates mean alpha values for rich and poor groups using the mean reporter, which computes averages over specified groups of turtles.
• Report-values Procedure:
  • Displays the computed mean alpha values for rich and poor turtles in the Command Center, enabling you to observe their changes over time.

By running this model in NetLogo, you will observe the movement of turtles while simultaneously calculating and displaying the average alpha for rich and poor turtles in each simulation step. This setup allows for dynamic tracking of these values throughout the simulation’s progression.

Histogram

Creating histograms in NetLogo involves first calculating the values you want to visualize and then using the plotting features provided by NetLogo. For your scenario, you need to calculate a QA value for each turtle based on the formula you provided and then plot histograms for rich and poor turtles separately.

Here’s a detailed step-by-step guide:

1. Update your model to calculate QA: Add the consume procedure to your model, which calculates QA for each turtle.

2. Set up a plot for each group: NetLogo plots can be configured to display histograms. You’ll need to create two plots: one for rich turtles and one for poor turtles.

Updated Code with Histogram Plotting

First, adjust your existing code to include a method for computing and plotting histograms:

globals [priceA alpha-globals-rich alpha-globals-poor]
turtles-own [income rich alpha QA]

to setup
  clear-all
  set priceA 50  ; Define a price for PriceA, required for the consume calculation
  create-turtles 100 [
    setxy random-xcor random-ycor
    set income random-normal 100 10
    if income > 50 [set rich true]
    if rich = true [
      set alpha random-normal 0.1 0.01
    ]
    if rich = false [
      set alpha random-normal 0.2 0.02
    ]
    consume
  ]
  setup-plots
  reset-ticks
end

to go
  ask turtles [
    fd 1
    rt random 90
    lt random 45
    consume
  ]
  update-plots
  tick
end

to consume
  set QA (alpha * income) / priceA  ; Calculate QA as specified
end

to setup-plots
  set-current-plot "Rich Turtle QA"  ; Prepare plot for rich turtles
  set-plot-x-range 0 10
  set-plot-y-range 0 100
  histogram [QA] of turtles with [rich = true]

  set-current-plot "Poor Turtle QA"  ; Prepare plot for poor turtles
  set-plot-x-range 0 10
  set-plot-y-range 0 100
  histogram [QA] of turtles with [rich = false]
end

to update-plots
  set-current-plot "Rich Turtle QA"
  clear-plot
  histogram [QA] of turtles with [rich = true]

  set-current-plot "Poor Turtle QA"
  clear-plot
  histogram [QA] of turtles with [rich = false]
end

Explanation:

• consume Procedure: This procedure calculates the QA value for each turtle. It should be called during setup and in every tick of the simulation.

• Plot Setup: Ensure that you have two plots configured in your NetLogo interface, named “Rich Turtle QA” and “Poor Turtle QA” respectively.

• setup-plots Procedure: Initializes the plot range and creates the initial histogram based on QA values for rich and poor turtles.

• update-plots Procedure: Updates plots in each tick of the simulation. It clears and redraws histograms as turtle values change.

Adding and Configuring Plots in the Interface:

1. Add Plots: In the NetLogo Interface, click on the “Add” button to add two plots. Set their names to “Rich Turtle QA” and “Poor Turtle QA”.

2. Configure Plots: Use the plot settings to adjust the x-range to match the expected range of QA values and the y-range to accommodate your number of turtles.

3. Visualize: Run the model to see how QA values distribute across rich and poor turtle populations.

By following these steps, you create two histograms that allow you to compare the distribution of QA between rich and poor turtles in your model. Adjust plot ranges and other settings as required by your specific use case and parameter values.

The errors you’re encountering typically result from issues with plot setup and naming in NetLogo. Let’s address these step-by-step, ensuring everything is correctly configured.

Key Steps to Resolve the Errors:

1. Ensure Plots Exist: Make sure that the plots “Rich Turtle QA” and “Poor Turtle QA” are correctly created in the NetLogo Interface.

2. Plot Setup in the Interface:

   • Create Plots: In the NetLogo interface, you’ll need to have the plot widgets added.
   • Name the Plots: Make sure the plots are named exactly “Rich Turtle QA” and “Poor Turtle QA”. This is case-sensitive.

3. Properly Define the Setup Procedures:

Here’s a revised version of the code, ensuring proper procedure names and avoiding the use of setup-plots, which conflicts with NetLogo’s reserved naming:

globals [priceA alpha-globals-rich alpha-globals-poor]
turtles-own [income rich alpha QA]

to setup
  clear-all
  set priceA 50  ; Define a price for PriceA, required for the consume calculation
  create-turtles 100 [
    setxy random-xcor random-ycor
    set income random-normal 100 10
    if income > 50 [set rich true]
    if rich = true [
      set alpha random-normal 0.1 0.01
    ]
    if rich = false [
      set alpha random-normal 0.2 0.02
    ]
    consume
  ]
  setup-qa-plots  ; Calls the setup for QA plots
  reset-ticks
end

to go
  ask turtles [
    fd 1
    rt random 90
    lt random 45
    consume
  ]
  update-qa-plots  ; Calls update for the plots
  tick
end

to consume
  ; Calculate QA based on alpha and income
  set QA (alpha * income) / priceA
end

to setup-qa-plots
  ; Initialize plots: make sure to execute this after creating plot widgets in the interface

  set-current-plot "Rich Turtle QA"
  set-plot-x-range 0 10  ; Set X range based on expected QA values
  set-plot-y-range 0 100  ; Set a sample Y range; adjust as needed
  
  set-current-plot "Poor Turtle QA"
  set-plot-x-range 0 10
  set-plot-y-range 0 100
end

to update-qa-plots
  ; Clears and updates the histograms for both rich and poor turtles

  set-current-plot "Rich Turtle QA"
  clear-plot
  histogram [QA] of turtles with [rich = true]

  set-current-plot "Poor Turtle QA"
  clear-plot
  histogram [QA] of turtles with [rich = false]
end

Additional Steps:

• Add Plot Widgets: Ensure you have manually added two plot widgets in the NetLogo interface, labeled “Rich Turtle QA” and “Poor Turtle QA”.

• Manual Configuration: Setup the axes ranges and labels using the plot editor if needed within the NetLogo GUI.

• Run Setup: After ensuring plots are created and appropriately named, the setup and go buttons should initialize and update the plots.

By carefully following these steps and ensuring your NetLogo interface is properly configured, you should be able to view histograms reflecting the QA values of rich and poor turtles without errors. Adjust the axis ranges in the interface if your QA values exceed or don’t fill the plot range.

Sum

To calculate and output the sum of all turtles’ incomes using the wealth procedure you have outlined, there are a few adjustments to make sure everything works correctly and effectively. Let me provide a refined piece of code and explain how to accumulate and display the total income of all turtles.

Modifications and Explanation:

1. Calculate Sum of Incomes: You’ll want to ensure that each turtle’s income is calculated correctly in the work procedure and then summed up in the wealth procedure.

2. Output: Ensure that the procedure correctly calculates EduInc (the sum of all turtle incomes) every time wealth is called and outputs it appropriately.

Here’s the revised code:

globals [EduInc]

turtles-own [U graduate income]
patches-own [degree pay]

to setup
  clear-all
  create-turtles 100 [
    set U random-normal 0 1
    setxy random-normal 0 5 random-normal 0 5
    set graduate false
    set income 0 ; Initialize income to 0 for all turtles
  ]
  ask patches [
    set pay random-normal 10 2
  ]
  universities
  work-place
  reset-ticks
end

to universities
  ask patch -10 1 [
    set pcolor green
    set degree 2
  ]
  ask patch 10 1 [
    set pcolor green
    set degree 2
  ]
end

to work-place
  ask n-of 10 patches [
    set pcolor brown
    set pay pay + random-normal 5 1
  ]
end

to go
  ask turtles [
    seek-education
    work
  ]
  wealth ; Update and print total income after each go
  tick
end

to seek-education
  if U > 0 and graduate = false [
    let closest-university min-one-of patches with [pcolor = green] [distance myself]
    move-to closest-university
    wait 0.05 ; pauses the turtle for a brief moment
    set graduate true
  ]
end

to work
  ifelse graduate = true [
    move-to one-of patches with [pcolor = brown]
    set income income + ([pay] of patch-here)
  ] [
    ;; Assuming black patches are areas without additional income
    ;; Ensure there are patches set to black, if required
    set income income + 0
  ]
end

to wealth
  set EduInc sum [income] of turtles
  print (word "Total Income of All Turtles: " EduInc)
end

Key Points:

• Initialization: Ensure each turtle’s income starts at zero when they’re created.

• Updating Income: In the work procedure, when a turtle moves to a brown patch, its income is increased by the pay of that patch. If turtles move to patches that are not brown (as specified in your code currently), their income should reflect those conditions (e.g., set to zero for supposed black patches).

• Summing Income: In the wealth procedure, the sum function aggregates all turtles’ incomes and stores it in EduInc, which is then printed.

• Execution: Call the wealth procedure in the go procedure to output the total income each tick.

This setup will allow you to monitor the total income of all turtles in your model and have it printed as part of each simulation tick. Adjust the output method based on your interface (e.g., using Monitor, Output area, or console).

csv

Exporting data from NetLogo is an effective way to analyze your simulation results using external tools like R, Python, Excel, or any software that supports CSV (Comma Separated Values) files. Below are steps and NetLogo code snippets to help you export the turtle attributes and global variables after a specified number of ticks.

Steps to Export Data:

1. Select the Attributes: Decide which turtle attributes and global variables you want to export. In this case, it’s income, who, and graduate for turtles, and EduInc for global variables.

2. Plan the Export Trigger: Determine when you want to perform the export. You mentioned “after 10 ticks.”

3. Write to a CSV File: Use the file-open, file-close, and file-print commands to manage file reading and writing.

NetLogo Code to Export Data:

Here’s a code snippet that you can integrate into your existing model to perform the desired data export after 10 ticks:

to go
  ask turtles [
    seek-education
    work
  ]
  wealth ; Update total income
  if ticks = 10 [
    export-turtle-data
  ]
  tick
end

to export-turtle-data
  ; Open a file to write the data. The filename can be adjusted to your preference.
  file-open "turtle-data.csv" 
  
  ; Write the header row
  file-print "who,income,graduate,EduInc"
  
  ; Loop through all turtles and write their data to the file
  ask turtles [
    file-print (word who "," income "," graduate "," EduInc)
  ]
  
  ; Close the file after writing
  file-close
  
  ; Optional: Print a message to confirm the export
  print "Turtle data has been exported."
end

Explanation:

• Data Collection: During each tick, the go procedure allows turtles to perform their tasks. After exactly 10 ticks, export-turtle-data is called to export the data.

• Opening the File: file-open "turtle-data.csv" opens (or creates) a CSV file named “turtle-data.csv” in your working directory for writing.

• Writing Headers: Writes the CSV headers based on the attributes you’re exporting.

• Writing Data: The file-print command outputs each turtle’s who identifier, income, and graduate status, alongside the global variable EduInc, into the CSV format.

• Handling Global Variables: The EduInc variable is recorded alongside each turtle’s data for contextual reference.

• Closing the File: file-close ensures the file is properly closed and saved when you’re done writing.

Tips:

• Ensure file-open has a unique filename or path to prevent accidental data overwriting.

• Use file-write followed by file-newline if you prefer more manual control over file formatting rather than file-print.

• Verify the model’s permissions/settings to allow file I/O operations based on your environment (some environments may have restrictions).

After running your simulation with this code, you’ll find a CSV file in the specified directory containing the recorded data. You can then open this in a text editor, spreadsheet software, or a data analysis tool for further analysis.