Question on hw1

[swilliamson7]

I mentioned after class that I'm confused about a part of the Abelian sandpile question, specifically:

Using the code included below, show that your model exhibits a $1/T^\alpha$ waiting time between avalanches, where $\alpha$ is some constant.

I think I don't understand what we mean by waiting time. My initial understanding was that we wanted to look at how many steps went by between avalanches (so if we had an avalanche at step j and another at step k, we'd look at the difference of those two as the waiting time), but when I did this those waiting times just appeared random. Am I misunderstanding what I'm supposed to look at here? I see now that your code includes arrays with avalanche times, sizes, and durations, was the plan to do something with these?

[williamgilpin]

My bad, I think I should probably modify that to say "durations." try running those cells as is and it should calculate those statistics; here's the abridged code that does it

all_events =  [model.check_difference(*states) for states in zip(model.history[:-1], model.history[1:])]
all_events = all_events[1000:] # remove transients
all_avalanche_durations = [event1 - event0 for event0, event1 in zip(all_avalanche_times[:-1], all_avalanche_times[1:])]
log_bins = np.logspace(np.log10(2), np.log10(np.max(all_avalanche_durations)), 50) # logarithmic bins for histogram
vals, bins = np.histogram(all_avalanche_durations, bins=log_bins)
plt.figure()
plt.loglog(10**bins[:-1], vals, '.', markersize=10)

[swilliamson7]

Okay cool, thank you!

[adamscottc]

During the avalanche portion, how can one grain go into each of the nearest eight sandpiles if the toppling sandpile has only four grains? It seems like we'd either end up spontaneous creating more grains than we started with or there wouldn't be enough grains to go to around. Is the avalanche only supposed to go into the four corner adjacent cells or maybe the four side adjacent cells?

[swilliamson7]

I believe sand falls only into adjacent neighbors, so not diagonal! Like you explained, this is what makes the most sense if a cell only has four grains

[williamgilpin]

yeah that's right. abelian sandpile uses the von neumann neighborhood instead of the moore neighborhood that the game of life uses, although there are generalizations to arbitrary random graphs

[williamgilpin]

0 and 1 are flipped in percolation

[williamgilpin]

okay i think i fixed it everywhere. other implementations seem to favor 0 == blocked and 1 == open, so i'm trying to stick with that throughout.

[swilliamson7]

The last question on the percolation problem suggests we watch videos of the simulation on the class website but I can't seem to locate them. Could you point out where the videos are?

[williamgilpin]

oops my bad, thank you---I just updated the HW to link to a video

[swilliamson7]

Thank you! A follow up question now seeing the video: why does it look like the grid itself is changing beyond just being filled with water? It looks like black sites are turning grey as time passes. Or are we looking at different simulations and so different initial grids?

[williamgilpin]

Good point, in the video I'm changing $p$ by gradually "opening up" blocked sites until it percolates. But I just realized that since the problem focuses on static percolation in a fixed lattice, it's not clear that's what I am referring to here.
(My original thought is that unblocking sites is like dropping sandgrains)

I'll revise the question wording now

[adamscottc]

In the second part of the Percolation problem, when it asks "how the probability of percolation changes as a function of N?", is it referring to the plot that we created of the probability of percolation changes vs the fraction of open sites p? Or do we need to create a separate plot analyzing the probability as a function of the lattice size too?

[williamgilpin]

oops that looks like a typo, just probability as a function of $p$, the blockage probability. i've updated the notebook

[erfanhamdi]

I had this question about the vectorized implementation of Abelian sandpile.
Here I have implemented my version of it, but it resulted in a 3 times slower execution time in comparison with the recursive implementation.
https://github.com/erfanhamdi/cphy_problems/blob/main/cellular_automata/README.md
Actually, I guess that's because using this way of vectorization updates the whole grid, while maybe it just makes sense to do that only in later steps.
Is there any way to make it work faster?

[williamgilpin]

Hi Erfan, I think recursive is globablly faster overall. Checking all the lattice sites costs a factor of $N$, whereas recursion only requires checking sites where $z \geq 4$. The number of sites this applies to is still $\sim N$, but the bound is tighter, since we can, in principle, check only the edges of the avalanche until it peters out, leading to savings in cases of small avalanches especially.

[erfanhamdi]

Hi William
I was working on the percolation problem and had this result when p=0.1, there was a cell that wasn't filled :[14, 13]

but in the figures inside the provided notebook that cell is filled, but I don't get why should that happen. Because of the rules on directed percolation, the cell should have neighbors at its top or sides, or maybe I'm missing something here

[erfanhamdi]

Maybe it is somehow representing pressure
but shouldn't that build-up due to pressure in those places happen when the water doesn't percolate ?

[williamgilpin]

If you are doing the iterative (row-wise) solution, then try flipping the lattice over and running the percolate method again, to fill those sites. Not necessary to get the right $p_c$, but it is necessary to match the DFS solution

[erfanhamdi]

Oh, thanks. I was missing the rules. Yes I was using the iterative solution