PWS percolatie en verkeersstromen

pascalv

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).

Percolatie_v02

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()

Define matrix size and percolation probability

matrix_size = 10
percolation_probability = 0.7

Generate the percolation matrix

percolation_matrix = generate_percolation_matrix(matrix_size, percolation_probability)

Visualize the percolation matrix

visualize_percolation(percolation_matrix)

Check if percolation occurs

if percolates(percolation_matrix):
print("Percolation occurs!")
else:
print("No percolation.")

Percolatie_v03

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()

Define matrix size and percolation probability

matrix_size = 10
percolation_probability = 0.4

Generate the percolation matrix

percolation_matrix = generate_percolation_matrix(matrix_size, percolation_probability)

Visualize the percolation matrix

visualize_percolation(percolation_matrix)

Check if percolation occurs

if percolates(percolation_matrix):
sys.stdout.write("Percolation occurs!\n")
else:
sys.stdout.write("No percolation.\n")

Percolatie_v04

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? '))

print(type(grid_size))

print(grid_size)

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

# print(labels)

label_grid, aantal_groepen = label(grid)
print(label_grid)

print(aantal_groepen)

im.plot(label_grid, origin='lower',cmap = 'rainbow')
cluster_nummers = np.arange(1,label_grid.max()+1)

print(cluster_nummers)

np.random.shuffle(cluster_nummers)
cluster_nummers = np.append(0,cluster_nummers)

print(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")

percolatie_v05

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 = float(input('Wat is de bezettingskans? '))

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)

naming the x axis

plt.xlabel('x - axis')

naming the y axis

plt.ylabel('y - axis')

giving a title to my graph

plt.title('Aantal percolatie vs p voor '+ aantal_runs +' runs')

function to show the plot

plt.show()

pascalv

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?

pascalv

Of kunnen we misschien rechten krijgen om bestanden aan een bericht toe te voegen?

lennardd

Hey @pascalv,

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.

Groetjes,
Lennard

pascalv

@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

lennardd

Hey @pascalv,

Excuses voor mijn late reactie! Het lukte me in eerste instantie niet om wat tijd te vinden me te verdiepen in jullie code. Vandaag wel! De eerste twee bestanden kan ik runnen, de laatste twee lukte niet omdat daarin wat verouderde functies van Numpy worden gebruikt. Het idee is me echter wel duidelijk. Om een blokkade in te bouwen is het belangrijk om eerst tijdsafhankelijkheid in te bouwen, anders heeft een blokkade ook niet zoveel zin. Hiervoor zou je bijvoorbeeld kunnen kijken naar de volgende code in Java die dit op een heel eenvoudige manier doet. Hierbij is zowel tijdsafhankelijkheid ingebouwd als een blokkade zodat je kunt onderzoeken wat dit voor effect heeft in de tijd. Enige punt is dat je dit nog wel moet vertalen naar Python, maar de belangrijkste ideeën kun je hier in ieder geval uithalen.

Alternatief kun je deze code gebruiken die ik even snel heb gemaakt vanmiddag. Ik had geen tijd om from scratch alles te maken, dus ik heb ChatGPT gevraagd een mooi stukje code te schrijven en hier de onvermijdelijke fouten uitgehaald. Hopelijk helpt dit jullie wat op weg. Het aantal tijdstappen is variabel evenals de grootte van het grid en de output is een mooie animatie van de percolatiematrix. Wat je kunt doen om vaste blokkades in te voeren is door een list objects te maken met punten die je moet overslaan in de loop (if (i,j) in objects: continue o.i.d.). Ook is er nu nog niets gemaakt wat de in- of uitstroom van passagiers kan simuleren, maar dit is in ieder geval al een stap in de juiste richting.

Nogmaals excuses voor mijn late reactie, dit was helaas niet binnen mijn standaard 3 dagen. Hopelijk heb ik jullie hiermee toch wat kunnen helpen, maar als je verder nog vragen hebt, hoor ik het graag! Ook een keer videobellen kan altijd, laat maar weten.

Groetjes,
Lennard

pascalv

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

Hey @pascalv,

Om de tijdstap aan te passen kun je in FuncAnimation toevoegen interval=1000, waarbij het interval in ms wordt gemeten. Op de gestuurde pagina staan links naar Java files, e.g. VerticalPercolation.java. De tekst van jullie link is inderdaad een op een vergelijkbaar met de tekst van Princeton University die ik stuurde; deze wordt ook als bron vermeld voor jullie pagina. Voor formules en wiskundige oplossingen zou je eens een boek over percolatie moeten openslaan. Ik denk dat dit al veel zou helpen om wat meer de diepte in te duiken. Je kunt bijvoorbeeld eens kijken naar een van de volgende boeken die gebruikt worden op veel universiteiten. Hoewel dit vooral gaat om de toepassingen van percolatie in natuurkunde, blijft de wiskunde erachter natuurlijk hetzelde:
https://drive.google.com/drive/folders/19eRYoR4YjE37_GVfgFfLOn0w81vU7Aqo?usp=sharing

Hopelijk heb ik jullie hiermee kunnen helpen, maar als je verder nog vragen hebt, hoor ik het graag!

Groetjes,
Lennard

pascalv

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.

lennardd

Hey @pascalv,

In de praktijk is de p-waarde niet meer dan de dichtheid van de bezoekers. Je zou dat uit kunnen drukken als N/M waarbij N het aantal bezoekers is en M het maximum aantal bezoekers. Zo heb je dus ook een waarde tussen 0 en 1. Volgens mij hangt dit voornamelijk af van twee factoren: de instroom op het vliegveld en de uitstroom op het vliegveld. Als de uitstroom lager is dan de instroom zal de p-waarde steeds hoger worden en uiteindelijk percolatie optreden.

Laat maar weten als jullie nog meer vragen hebben!

Groetjes,
Lennard