Lennard, bedankt voor je snelle reactie, dit werkt! Een vraag die we nog hebben is hoe we de p-waarde in de praktijk kunnen interpreteren als het gaat over de doorstroming op Schiphol, dus wat invloed kan hebben op de p-waarde. Heb je daar nog suggesties voor?
Vriendelijke groeten,
Pascal en Matthias.
Lennard bedankt!
Bij het draaien (grid 10, p=0.6) valt op dat vooral de linkerkant zwart is, dus daar is vaker percolatie. Kun je verder nog de tijdsduur per time-step instellen? Nu gaat het zo snel dat je niet kunt zien hoe de percolatie verloopt. Verder is niet duidelijk welke code in java precies bedoeld wordt, waar staat die precies? Die tekst met java lijkt ook veel op https://rstudio-pubs-static.s3.amazonaws.com/241232_eebe419a0aaa4eb89398ee2a61ad3dc2.html. In dat stuk staat ook dat er geen wiskundige oplossing is om de drempelwaarde te bepalen en dat je die alleen maar kunt schatten. Klopt dat? We willen ook nog een praktisch experiment doen met percolatie, maar we zoeken daar eigenlijk formules bij die we hiervoor kunnen gebruiken., zijn die er ook?
Alvast bedankt voor een reactie.
Met vriendelijke groet,
Matthias en Pascal
@lennardd zegt in PWS percolatie en verkeersstromen:
Dat is vervelend! Kun je dan misschien je code uploaden naar Google Drive of OneDrive en een gedeelde link (alleen bekijken) hier op het forum plakken?
Dan kan ik jullie code wat beter bekijken.
Hallo Lennard,
Hierbij de links.
v02 https://drive.google.com/file/d/1kMhvoBBt3At6HitCF77h1w-5RfxAyeZK/view?usp=sharing
v03 https://drive.google.com/file/d/1DnLZ1n618dXdLieiR9J_H2Sok7upxG74/view?usp=sharing
v04 https://drive.google.com/file/d/1clvg3uoPcWSxH2q0dgeBA4DK9EJpLU61/view?usp=sharing
v05 https://drive.google.com/file/d/1IfgYTrtnU4wf4Chb4JUR95vVYXP7EQV1/view?usp=sharing
Met vriendelijke groet,
Pascal en Matthias
Of kunnen we misschien rechten krijgen om bestanden aan een bericht toe te voegen?
Zo te zien gaat het nu ook weer niet goed. Er worden dik en dungedrukte regels van gemaakt. Is er nog een andere manier om documenten tioe te voegen?
Hallo Lennard,
Hierbij de codes v02 en v03 van het simpele model, waarbij het grid en de p-waarden vastliggen in de code. Bij de code v04 kunnen de afmetingen van het grid en de bezettingskans. worden opgegeven. Dit geeft gekleurde plots. Met v05 kan de afmeting van het grid worden opgegeven en het aantal iteraties bij een bepaalde waarde van p. Het gedeelte tussen 0 en 1 is hierbij opgesplistst in 50 p-waarden. Dat geeft een plot waarin te zien is bij welke drempelwaarde van p er percoltaie plaatsvindt.
Wat we zouden willen is dat er op een of ander manier iets van tijd in het proces in te bouwen is. Dan gaat het vooral om code v04. Als het zou gaan om de doorstroming van een hal in Schiphol heb je steeds een veranderend aantal instroom en uitstroom. De route kan geblokkeerd worden door personen die stoppen of in groepjes ergens staan. Ook zou je bepaalde cellen in het grid voortdurend willen blokkeren (p=0) omdat daar iets staat waar men omheen moet. En de bezettingskans kan ook samen hangen met de instroom. Dus bij hoge instroom zou de p laag zijn, omdat er weinig doorstroom is.
Mocht je suggesties hebben hoe dit in te bouwen is in onze code dan zou dat mooi zijn.
Vriendelijke groet,
Pascal en Matthias
PS het gebruk van de document-button geeft de melding : Fout Onvoldoende rechten om deze actie uit te voeren.
Dus hieronder de codes als tekst toegevoegd (dit ging de vorige keer niet helemaal goed).
import random
import numpy as np
import matplotlib.pyplot as plt
from scipy.ndimage import label
def generate_percolation_matrix(n, p):
return np.random.rand(n, n) < p
def percolates(matrix):
labeled_matrix, num_labels = label(matrix)
top_labels = labeled_matrix[0, :]
bottom_labels = labeled_matrix[-1, :]
common_labels = np.intersect1d(top_labels, bottom_labels)
return len(common_labels) > 0
def visualize_percolation(matrix):
plt.imshow(matrix, cmap='binary')
plt.title("Percolation Matrix")
plt.colorbar()
plt.show()
matrix_size = 10
percolation_probability = 0.7
percolation_matrix = generate_percolation_matrix(matrix_size, percolation_probability)
visualize_percolation(percolation_matrix)
if percolates(percolation_matrix):
print("Percolation occurs!")
else:
print("No percolation.")
import random
import numpy as np
import matplotlib.pyplot as plt
import sys
def generate_percolation_matrix(n, p):
return np.random.rand(n, n) < p
def percolates(matrix):
def dfs(x, y):
if x < 0 or x >= matrix.shape[0] or y < 0 or y >= matrix.shape[1]:
return False
if matrix[x, y] == 0:
return False
if visited[x, y]:
return False
visited[x, y] = True
if x == matrix.shape[0] - 1:
return True
# Recursively check neighboring cells
result = (dfs(x + 1, y) or
dfs(x - 1, y) or
dfs(x, y + 1) or
dfs(x, y - 1))
return result
visited = np.zeros_like(matrix, dtype=bool)
for y in range(matrix.shape[1]):
if matrix[0, y] == 1:
if dfs(0, y):
return True
return False
def visualize_percolation(matrix):
plt.imshow(matrix, cmap='binary')
plt.title("Percolation Matrix")
plt.colorbar()
plt.show()
matrix_size = 10
percolation_probability = 0.4
percolation_matrix = generate_percolation_matrix(matrix_size, percolation_probability)
visualize_percolation(percolation_matrix)
if percolates(percolation_matrix):
sys.stdout.write("Percolation occurs!\n")
else:
sys.stdout.write("No percolation.\n")
import numpy as np
import imagesc as im
import matplotlib as plt
from scipy.ndimage import label
def union(a, b):
labels[find(b)] = find(a)
def find(a):
while labels[a] != a:
a = labels[a]
print (a)
return a
grid_size = input('Wat zijn de afmetingen van het grid? (gescheiden met komma) ')
grid_size = tuple(int(item) for item in grid_size.split(','))
p = float(input('Wat is de bezettingskans? '))
grid = np.empty(shape = grid_size, dtype= int)
for i in range(np.size(grid, 0)): # Gehele grid invullen met bezetting
for j in range(np.size(grid, 1)):
grid[i, j] = np.random.binomial(1, p)
# binominale verdeling uitvoeren met p als kans op succes
label_grid, aantal_groepen = label(grid)
print(label_grid)
im.plot(label_grid, origin='lower',cmap = 'rainbow')
cluster_nummers = np.arange(1,label_grid.max()+1)
np.random.shuffle(cluster_nummers)
cluster_nummers = np.append(0,cluster_nummers)
label_grid_shuffled = cluster_nummers[label_grid]
im.plot(label_grid_shuffled, origin='lower',cmap = 'rainbow')
a =np.intersect1d(label_grid[0,:],label_grid[len(label_grid)-1,:])
percolatie_clusters= a[a != 0]
if percolatie_clusters.any():
print("Er is sprake van percolatie")
print(percolatie_clusters)
else:
print("Er is geen sprake van percolatie")
import numpy as np
import imagesc as im
import matplotlib.pyplot as plt
from scipy.ndimage import label
grid_size = input('Wat zijn de afmetingen van het grid? (gescheiden met komma) ')
grid_size = tuple(int(item) for item in grid_size.split(','))
aantal_runs = input('Hoevaak itereren? ')
p= np.linspace(0,1,num=50)
aantal_percolaties = np.zeros(len(p))
for l in range(len(p)):
for k in range (int(aantal_runs)):
grid = np.empty(shape = grid_size, dtype= int)
for i in range(np.size(grid, 0)): # Gehele grid invullen met bezetting
for j in range(np.size(grid, 1)):
grid[i, j] = np.random.binomial(1, p[l])
label_grid, aantal_groepen = label(grid)
# print(label_grid)
a =np.intersect1d(label_grid[0,:],label_grid[len(label_grid)-1,:])
# print(a)
percolatie_clusters= a[a != 0]
if percolatie_clusters.any():
aantal_percolaties[l] = aantal_percolaties[l] +1
print(aantal_percolaties)
plt.plot(p, aantal_percolaties)
plt.xlabel('x - axis')
plt.ylabel('y - axis')
plt.title('Aantal percolatie vs p voor '+ aantal_runs +' runs')
plt.show()
Hallo Lennard,
Vanwege een toetsweek een late reactie. We willen graag het eenvoudige model aanpassen, door er de variabele tijd aan toe te voegen. Hoe kunnen wij onze code die we nu hebben als bijlage toevoegen?
Vriendelijke groet,
Pascal en Matthias
Hallo Lennard,
Bedankt voor je reactie. Door een drukke periode reageren we nu pas. We zijn eigenlijk nog aan het nadenken over een geschikt experiment. We zijn uitgegaan van percolatie in koffie en hoe dat werkt. Daarna hebben we gekeken hoe we in Python iets konden maken waarmee je percolatie kan vaststellen. Dat hebben we nu voor een rooster uitgezocht waarvan we de afmetingen kunnen aanpassen. Daarmee kunnen we de drempelwaarde bepalen. De percolatie hangt af van p, dus de kans of een cel in het rooster geblokkeerd is of niet. Dus van dit model zijn we uitgegaan.
We wilden eigenlijk iets doen met de verkeersstromen op Schiphol en hoe je daar iets over kan zeggen met de theorie van percolatie. We hebben wel cijfers over het aantal passagiers dat Schiphol dagelijks kan verwerken, maar het is ons nog niet helemaal duidelijk hoe we dat kunnen gebruiken met ons model.
Het zal afhangen van het aantal mensen dat op een dag naar Schiphol komt, hoeveel incheckpunten en poortjes er zijn en hoeveel personeel er werkt en hoeveel vluchten er zijn. Dit zal dan op een of andere manier de waarde van p bepalen.
Dat wordt waarschijnlijk erg ingewikkeld als overal rekening mee gehouden moet worden. Dus onze vraag is hoe we dit op een eenvoudige manier verder kunnen aanpakken.
Het artikel van Wang over percolatie en verkeer is voor ons al vrij ingewikkeld. We hebben nog wel wat uitgezocht. Een van de Chinese auteurs heeft later nog iets over percolatie geschreven: https://ieeexplore.ieee.org/document/8272794. maar dat is alleen een samenvatting. De laatste auteur (Havlin) heeft het meeste onderzoek gedaan over dit onderwerp: Percolation_on_Spatial_Anisotropic_Spatial_Networks en Interdependent transport via percolation backbones in spatial networks
Deze onderzoeker uit Israël hebben we benaderd omdat we zijn mailadres konden achterhalen. Die heeft onze vraag naar de code doorgestuurd naar een onderzoeker in China en die heeft weer verwezen naar de eerste auteur die nu in Washington zit. Dit is zijn antwoord dat we deze week ontvingen:
[link text]([link url](link url))The codes were developed in C++ not in Python. Honestly, I myself have switched to Python 7 years ago; the C++ codes are kind of barriers to me now.. I would suggest that you follow the rules defined in the paper and code them in Python on your own. I believe this would be even easier for you: some codes like BFS algorithm are directly available from python package, so that you do not need to code them from scratch like me using C++.
Another issue with the code sharing is that these codes are likely integrated to some bigger project that is patented by the lab PI. I am not sure what procedures I need to take to share the code.
Dus hij heeft ons uiteindelijk niet verder kunnen helpen met code. Het zelf omzetten van het artikel in een uitgebreid percolatie-model in Python is voor ons nogal lastig, omdat onze kennis maar beperkt is. We hadden zelf na veel uitzoekwerk al wat in Python opgezet (zie hieronder) maar dit was nog een hele klus. Zou dat nog makkelijk aan te passen zijn? Verder hebben we voor ons werkstuk maar beperkte tijd dus we willen eigenlijk kiezen voor een eenvoudige aanpak waar we verder mee aan de slag kunnen.
Zou jij nog iets voor ons kunnen betekenen of heb je misschien nog wat suggesties voor ons?
Met vriendelijke groet,
Matthias en Pascal
percolatie_plot_1
import numpy as np
import imagesc as im
import matplotlib as plt
from scipy.ndimage import label
def union(a, b):
labels[find(b)] = find(a)
def find(a):
while labels[a] != a:
a = labels[a]
print (a)
return a
print("Er worden 2 figuren gemaakt in kleur en zwart wit")
print("na afloop worden de waarden die bij de bezettingskans horen weergegeven")
print("en er wordt gemeld of er sprake is van percolatie")
print(" ")
grid_size = input('Wat zijn de afmetingen van het grid? (gescheiden met komma) ')
grid_size = tuple(int(item) for item in grid_size.split(','))
p = float(input('Wat is de bezettingskans? (tussen 0 en 1, decimale punt) '))
grid = np.empty(shape = grid_size, dtype= int)
for i in range(np.size(grid, 0)): # Gehele grid invullen met bezetting
for j in range(np.size(grid, 1)):
grid[i, j] = np.random.binomial(1, p)
# binominale verdeling uitvoeren met p als kans op succes
label_grid, aantal_groepen = label(grid)
print(label_grid)
im.plot(label_grid, origin='lower',cmap = 'rainbow')
cluster_nummers = np.arange(1,label_grid.max()+1)
np.random.shuffle(cluster_nummers)
cluster_nummers = np.append(0,cluster_nummers)
label_grid_shuffled = cluster_nummers[label_grid]
im.plot(label_grid_shuffled, origin='lower',cmap = 'gray')
a =np.intersect1d(label_grid[0,:],label_grid[len(label_grid)-1,:])
percolatie_clusters= a[a != 0]
if percolatie_clusters.any():
print("Er is sprake van percolatie")
print(percolatie_clusters)
else:
print("Er is geen sprake van percolatie")
Percolatie_plot_2
import numpy as np
import imagesc as im
import matplotlib.pyplot as plt
from scipy.ndimage import label
grid_size = input('Wat zijn de afmetingen van het grid? (gescheiden met komma) ')
grid_size = tuple(int(item) for item in grid_size.split(','))
aantal_runs = input('Hoevaak itereren? ')
p= np.linspace(0,1,num=50)
aantal_percolaties = np.zeros(len(p))
for l in range(len(p)):
for k in range (int(aantal_runs)):
grid = np.empty(shape = grid_size, dtype= int)
for i in range(np.size(grid, 0)): # Gehele grid invullen met bezetting
for j in range(np.size(grid, 1)):
grid[i, j] = np.random.binomial(1, p[l])
label_grid, aantal_groepen = label(grid)
# print(label_grid)
a =np.intersect1d(label_grid[0,:],label_grid[len(label_grid)-1,:])
# print(a)
percolatie_clusters= a[a != 0]
if percolatie_clusters.any():
aantal_percolaties[l] = aantal_percolaties[l] +1
print(aantal_percolaties)
plt.plot(p, aantal_percolaties)
plt.xlabel('x - axis')
plt.ylabel('y - axis')
plt.title('Aantal percolatie vs p voor '+ aantal_runs +' runs')
plt.show()
Hallo TUDelft,
We zijn bezig voor 6 VWO met een profielwerkstuk waarbij we aan de hand van percolatie iets over verkeerstromen willen zeggen, dus hoe we deze theorie dus in de praktijk kunnen toepassen op verkeersstromen. We dachten eerst aan passagiersstromen op Schiphol maar dat lijkt ons toch wel lastig. We hebben ook een paar artikelen gevonden waar we nu mee bezig zijn en die wat meer info geven. Er is al iets in python geprogrammeerd om percolatie te kunnen bepalen, waarbij we gebruik hebben gemaakt van Percolation theory using Python https://www.uio.no/studier/emner/matnat/fys/FYS4460/v20/notes/book.pdf.
We zijn bij het python programma uitgegaan van een eenvoudig model met nearest neighbor connectivity, waarbij we de p-waarde of een cel wel of niet gevuld is tussen 0 en 1 varieert.
Dit geeft voor een rooster van 10 x 10 met bijv een p van 0.4 op (zwart of dicht) het volgende figuur
Hier is geen percolatie want er is geen aaneengesloten rij van gevulde zwarte cellen van boven naar beneden.
Voor 10 x 10 rooster met p = 0.7 geeft dit figuur
Hier is wel percolatie want er is een aaneengesloten rij van zwarte cellen van boven naar beneden.
Dan hebben we voor een een 10 x 10 rooster voor 50 verschillende p-waarden 100 x een run gedaan. Dit geeft de volgende figuur
Je ziet dan dat de p-drempelwaarde waarbij percolatie plaats vindt ongeveer ligt bij 0.3. Boven 0.8 is er altijd percolatie.
Als het gaat over verkeersstromen door bijvoorbeeld een stad, wat zou dan de grootte van de p-waarde kunnen bepalen?
We hebben ook een artikel bekeken over percolation properties in a traffic model
https://arxiv.org/ftp/arxiv/papers/1512/1512.00182.pdf
Dit artikel over het traffic model en doorstroming is nog vrij ingewikkeld. De vraag is of we daar een eenvoudige formule kunnen uithalen die we in de praktijk, in combinatie met python, kunnen gebruiken voor bijvoorbeeld een experiment.
Hebben jullie ervaringen met dit soort onderzoek naar percolatie of hebben jullie tips hoe we dit verder kunnen aanpakken?
Alvast bedankt voor een reactie,
Pascal & Matthias.