In my Netlogo project the turtles (circles, that simulate tables in a restaurant) are not allowed to cross the worlds boarder, since there is the wall of the restaurant. Before setup the user can choose the tables diameter. I tried the following:
if xcor < (size / 2) or xcor > (32 - (size / 2)) [ find_new_spot ]
if ycor < (size / 2) or ycor > (32 - (size / 2)) [ find_new_spot ]
The idea was that if the xcor is smaler than the radius of the table, it has to find a new spot. Same goes with the ycor. But this does not work. Is there anything missing?
My Netlogo world is set up like the following:
Location of origin: corner (bottom left)
max-pxcor: 32
min-pxcor: 0
max-pycor: 32
min-pycor: 0
It's possible that they did find a new spot, but the new spot was also too close to the wall. You can debug that by putting a line into your find_new_spot procedure that tells you the location at the beginning of the procedure and then again at the end of the procedure. If that is your problem, then you need it to keep moving until it find an allowed spot, so you need a while loop.
Related
I am quite new to NetLogo, so I need some help figuring out a few things.
I have a requirement to generate turtles at random points and intervals when the go button is clicked. I have written the code mentioned below, but it generates turtles only when I click on the go button, and they are not moving properly. The go button I am using is a forever one, not the single-step button. Kindly help me where I am doing wrong.
to go
repeat num-students[
every t [
set t random 60
create-students 1 [
set xcor random -32 - 32
set ycor random -13 - -15]
ask students [
set size 2
set color blue
set heading ( 90)
forward random 10
]]]
end
I strongly recommend not using "every" -- it executes something every specified number of seconds in real time, which is very different from at random simulated times. You need code that decides at which ticks turtles are created. (I did not even know "every" existed until seeing this and have never seen it used.)
My first suggestion would be to indent your code, that makes it much easier to see which command fits into which block. You can do this by simply highlighting all of your code and clicking tab.
I am not very familiar with the every primitive but the following code works as intended and I can't seem to reproduce your problem of no extra turtles being made. Maybe it is just that your time interval is too big?
to setup
ca
set num-students 5
set t random 5
end
to go
every t [
set t random 5
create-students 1 [
set xcor random -32 - 32
set ycor random -13 - -15
]
ask students [
set size 2
set color blue
set heading ( 90)
forward random 10
]
if count students >= num-students [stop]
]
end
I removed the repeat num-students[] part since it didn't add anything to the code. It just makes you repeat the every command a few times inside each tick. Instead, I used if count students >= num-students [stop] in order to stop when the desired amount of students is reached.
Please let me preface this with I am not a programmer by trade. I am a social scientist using M&S for some research. That being said, my goal is to use ABM (Netlogo) to create a model of state antifragility. That is a model of states that get better under stress rather than deteriorate or are resilient (return to their pre-stress levels).
The idea for this model is simple. Create agents (states) that have three properties-loops, capacity and performance. The Capacity of a state is defined as it's Agility + it's Learning + it's Power Conversion. ( I've done some regression analysis to see what the relationship between each of these variables and stress is and they are listed below. ) The state also has two loops-fragile and antifragile that are always running, but depending on the performance value and the stress value only one of those loops will activate to update the capacity/performance values to deal with the next stress. Finally, a state's performance ties all those together. That is, it is a function of capacity and stress.
States randomly roam about the world full of shocks (red patches with an intensity value). When the state comes across the patch, it interacts with that patch. To interact, it activates a loop and then performs and update of its capacity and it's performance for the next stress. This happens until a state dies (it's too fragile and fails) or it becomes the maxium value of antifragile.
UPDATED CODE BELOW ( 22 July) JenB, I took your advice and stripped it down to it's basic parts by removing the looping functions. Eventually, I'd like to get there in a future iteration, but for now I removed it. The code below is my stripped down, updated version. Where I am stuck is the stop movement function.
Starting with the latter, I am still unsure how to set something true or false. I kept getting an error about a string not a value for that command. (Again, I am really, really a beginner at this and even reading the Netlogo Dictionary isn't that easy for me.)
Now that I think about it there is a third thing. I'd also like to randomize the value of the red patches ("shocks"). I believe the way I have it set up right now is that they all have the same value, but I'd like some to be bigger or smaller.
Thank all of you for all your help in this journey!
Please see the code below:
breed [states state]
states-own [learning powerconversion agility performance category]
patches-own [intensity]
;; TO SET UP ;;
to setup
clear-all
grow-shocks
set-default-shape states "dot"
create-states 10 [
setxy random-xcor random-ycor
set color blue
set size 2.5
set performance random 100
set learning random 10
set powerconversion random 10
set agility random 10
]
reset-ticks
end
;; TO GROWN SHOCKS ;;
to grow-shocks ;; to grow shocks in the international environment do the following:
ask n-of number-shocks patches [
set pcolor red ;; make them red
set intensity random 10 ;; set their intensity to a random number between 0-10
]
end
;; TO GO ;;
to go
ask states [ ;; ask states to do the following : move, interact, update-category (AF, R, F)
move
interact
update-category
]
tick
end
;; TO MOVE ;;
to move ;; to move do the following:
right random 15
left random 15
forward 1
if abs pxcor = max-pxcor
[ set heading (- heading) ]
if abs pycor = max-pxcor
[ set heading (180 - heading) ]
end
;; TO INTERACT ;;
to interact ;; to interact with shocks do the following:
if pcolor = red [
set pcolor black set intensity 0 ;; if the patch is red, turn the patch black and set intensity to 0
update-performance ;; update-performance
update-category
]
end
;; TO UPDATE PERFORMANCE ;;
to update-performance ;; to update a state's performance do the following:
set performance (((-0.13 * learning ^ 3) + (1.89 * learning ^ 2) + (-5.72 * learning) + 8.13 ) +( 0.09 * agility ^ 3) + (1.29 * agility ^ 2) + (-3.45 * agility) + 5.57 +( 0.02 * powerconversion ^ 3) + (-0.89 * powerconversion ^ 2) + (9.93 * powerconversion) + -17.51 )
end
;; TO UPDATE STATE TYPE;;
to update-category ;; to update the state's type do the following:
if performance > 75 [ ;; if the state has a performance value of over 75, turn it green indicating an antifragile state
set color green
]
if performance < 74 and performance > 35 [ ;; if the state has a performance value between 35 and 74, turn it yellow indicating a robust state
set color yellow
]
if performance < 34 and performance > 5 [ ;; if the state has a performance value between 1 and 34, turn it red indicating a failed state
set color red
]
So I am guessing the line throwing the too large error is this one:
to activate-antifragileloop
set performance e ^ performance
end
This seems like a logic error to me. From the rest of your code, I am guessing performance numbers are generally in the range 0 to 100. Do you realise that e^100 = 2.6881171 x 10^43? It seems unlikely that you want performance to switch between numbers like 100 and numbers with 43 digits. I can't imagine a real world situation that you could be trying to represent where a key characteristic of the entities in the system has such a wildly varying value.
On the question of stopping, I would have another variable named something like done? that starts as false then you set it to true when you want it to stop. Then you can simply have ask states with [not done?] instead of ask states for any code that moves them around etc.
You said you are not a programmer. One of the best things a beginner can do is to make only minimal changes at a time. You have several problems with your code - this should almost never happen. Your life will be much easier if you only make one change at a time and get it working correctly before moving on. This is particularly important with NetLogo where it can be very difficult to work out whether something is working correctly because you are modelling systems that interact - how do you know whether the interaction is producing the results or a bug is producing the results?
I am working on traffic simulation using netlogo. In attached image, i want to extend the road grids into two way road grid i.e. increase the width of each road grid. Here is the code that will need update but I am unable to do it myself.
set roads patches with [
(floor ((pxcor + max-pxcor - floor (grid-x-inc - 1)) mod grid-x-inc) = 0) or
(floor ((pycor + max-pycor) mod grid-y-inc) = 0)
]
Here is code that makes wider roads.
I tried to separate out the left lanes from the right lane so you can see what is happening if that helps you figure out where the cars should go.
I also separated the x-offset and y-offset values so you can adjust the grid in case you want to.
This code assumes that max-pxcor = 32, max-pycor = 32, and patch size = 6, so that the whole thing fits the same physical view area.
globals [
left-lanes
right-lanes
roads
]
to setup
clear-all
;; set the number of patches between lanes
let grid-x-inc 13
let grid-y-inc 13
;; offsets move the lanes slightly more to the right or further up
let x-offset grid-x-inc - 3
let y-offset -2
;; color the background
ask patches [set pcolor lime]
;; create the lanes
set left-lanes patches with [
(floor ((pxcor + max-pxcor - x-offset) mod grid-x-inc) = 2) or
(floor ((pycor + max-pycor - y-offset) mod grid-y-inc) = 2)
]
set right-lanes patches with [
(floor ((pxcor + max-pxcor - x-offset) mod grid-x-inc) = 1) or
(floor ((pycor + max-pycor - y-offset) mod grid-y-inc) = 3)
]
;; color the lanes for debugging purposes
; ask left-lanes [set pcolor yellow]
; ask right-lanes [set pcolor (yellow - 1) ]
;; merge left and right lanes into roads
set roads patches with [ member? self left-lanes or member? self right-lanes]
ask roads [ set pcolor yellow]
reset-ticks
end
to go
tick
end
OK, now I see what you are trying to do. You have a bigger problem than just drawing wider roads.
And I see now that you probably just want traffic just to go in one direction on each wider road, instead of simulating traffic going both directions.
OK, so you need to solve several design problems before anyone can answer your question about code.
(1) What do you want to display? Do you want just a wider yellow road? Or do you want pretty roads with lines along the sides like in the "Traffic 2 Lanes" model?
(2) Do you want the cars to actually use the two lanes, and include behavior such as changing-lanes and passing, like the "Traffic 2 Lanes" model?
AND ... the "Traffic 2 Lanes" model already includes all the logic and code you need for drawing wider roads, which would solve one of the two related questions you originally posted. Even if you only want fat yellow roads, not fancy roads with lines on them, the same logic could be used and you can just remove the part that draws lines.
This answers your first question:
i want to ... increase the width of each road grid.
BUT ... You actually asked a much harder question in your comment and in your original post's title:
i want to extend the road grids into two way road grid
I am not sure whether your original meaning has survived translation into English.
To me, a "two way road" means one road with two lanes, where there is traffic going both directions on the same road. Some cars would be heading North and some cars would be heading South.
This is far more complicated than the "Traffic Grid" problem in the Model Library In the "Traffic Grid" problem each road is only one lane wide, but it is also "one way".
Finally, I see that you did not give credit to Uri Wilensky or mention the models in the Model Library that is the source of most of the code you posted. It will be obvious to your college teacher that you copied large sections of code from someone else's work -- you should give credit to that person and cite the source of that code. It is still a major effort for your college final project to merge the logic from two models into one more complex model and get it to function.
I have my turtles go around randomly in my world. The problem is, I unwrapped it horizontally and vertically. I dont want to wrap it, but instead i just want it to bounce back if it reaches the border.Thank you very much.
Turtles have a variable heading indicating their direction in grades. If you don't want your turtle to keep going that way, you need to change that variable. So, I suggest that you use the variable headingand add 180 (forcing the turtle to turn around). Something like:
ask turtles [
if (xcor = minxcor or ycor = minycor or xcor = maxxcor or ycor = maxycor)
[
set heading heading + 180
]
]
where minxcor, minycor, maxxcor, maxycor are your bounds (depending on where your axis is situated: you can check that on the interface properties). So you're saying is: if you reach the end of the world, turn back. You can decide the grades, not necessarily 180. If you want to keep heading between 0 and 360 you can simply write set heading (heading + 180) mod 360.
If you have any doubt about what I've just written, feel free to ask!
I have a problem with following the nearest candida (breed) by another turtle - neutrophil (breed). Candidas can't move and neutrophil looks for the nearest candida in the area, face to him and go forward. Everything is fine when world is allowed to wrap. Then neutrophils go througt the "walls" and chase candida.
BUT the point is that world can't wrap.
So I created condidion with help another model, which bounce the neutrophil, when they reach one of the max coordinates. But now they keep bouncing from the walls and don't looking for another target.
I will be very thankful for help.
to lookfor ;;if meet candida in near area - chase, if not - continue looking for
ifelse any? candidas [ chase ] [ move ]
end
to chase ;;set the target on the nearest candida, face to them and move one step to him
set nearest-candidas min-one-of candidas [ distance myself ]
face nearest-candidas
bounce fd 1
end
to move
bounce
fd 2
end
to bounce
if abs pxcor = max-pxcor [ set heading (- heading) ] ;; bounce off top and bottom walls
if abs pycor = max-pycor [ set heading (180 - heading) ]
if abs pzcor = max-pzcor [ set heading (- heading) ]
set nearest-candidas max-one-of candidas [ distance myself ]
end
edit: Oh, you are in NetLogo 3D. That changes everything, unfortunately. Without being able to prevent the world from wrapping, there is no easy way of doing this. If you're feeling adventurous, you could try to find a way of ensuring that the nearest turtle is on the "right side of the wall" by triangulating with other turtles in the world. It wouldn't be easy though, but I could see that working. Good luck.
Outdated response:
I think the problem might be that in your bounce procedure, you have
set nearest-candidas max-one-of candidas [ distance myself ]
Using max-one-of sets the candidas to the one furthest AWAY from the neutrophil. You have it correctly in your chase procedure in which you set it to min-one-of (that is min one of, not max one of). Does changing that give you the behavior you were expecting?