python,scipy- homework -- how to keep history of the particle position in the grid

Question

i have the following problem:

Create a program where a particle will execute a random walk for N=1000 steps for these two cases: i) in a 1D system ii) in a 2D system. The program must calculate the mean(S) where S is the number of grid positions where the particle visited at least one time.You will make 10000 runs and find 10 points (one for every 100 steps ,from 0 to 1000) , which will be the means of 10000 runs.Do the plot of mean(S) in relation to time t.

I did this code:

import scipy as sc
import matplotlib.pyplot as plt
import random

plegma=1000
grid=sc.ones(plegma)   # grid full of available positions(ones)    

for p in range(10000):
    #-------------------Initialize problem-------------------------------------------------
    his_pos=[]                  # list which holds the position of the particle in the grid
    in_pos = int(sc.random.randint(0,len(grid),1))            #initial position of particle
    means=[]                                                    #list which holds the means 
    #--------------------------------------------------------------------------------------
    for i in range(0,1000,100):
        step=2*sc.random.random_integers(0,1)-1        #the step of the particle can be -1 or 1
        # Check position for edges and fix if required
        # Move by step
        in_pos += step
        #Correct according to periodic boundaries
        in_pos = in_pos % len(grid)  

        #Keep track of random walk
        his_pos.append(in_pos)
        history=sc.array(his_pos)
        mean_his=sc.mean(history) 
        means.append(mean_his)


plt.plot(means,'bo')
plt.show()

UPDATED -------------------------------------

import scipy as sc
import matplotlib.pyplot as plt
import random

plegma=1000
his_pos=[] # list which holds the number of visited cells in the grid
means=[] #list which holds the means

for p in range(10000):
    #-------------------Initialize problem-------------------------------------------------
    grid=sc.ones(plegma)   # grid full of available positions(ones)      
    in_pos = int(sc.random.randint(0,len(grid),1))            #initial position of particle
    num_cells=[]       # list which holds number of visited cells during run                         
    #--------------------------------------------------------------------------------------
    for i in range(1000):
        step=2*sc.random.random_integers(0,1)-1 #the step of the particle can be -1 or 1

        # Check position for edges and fix if required
        # Move by step
        in_pos += step
        #Correct according to periodic boundaries
        in_pos = in_pos % len(grid)  

        grid[in_pos]=0  # mark particle position on grid as "visited"

        if (i+1) % 100 == 0:

            number=1000-sc.sum(grid)  # count the number of "visited positions" in grid
            num_cells.append(number)  # append it to num_cells

      his_pos.append(num_cells) # append num_cells to his_pos
      history=sc.array(his_pos)


mean_his=history.mean(1)
means.append(mean_his)

UPDATE 2 ----------------------------- .....

    if (i+1) % 10 == 0:

            number=1000-sc.sum(grid)  # count the number of "visited positions" in grid
            num_cells.append(number)  # append it to num_cells

    his_pos.append(num_cells) # append num_cells to his_pos
    history=sc.array(his_pos)
mean_his=history.mean(0)

plt.plot(mean_his,'bo')
plt.show()

Thanks!

Answer 1

I am not sure of understanding what the problem is asking for (where time t is considered in your equations?, what do point refer to?), but relative to the operations you are trying to carry out, I understand you have to include each or your 10-means mean_his arrays resulting from each iteration in a final 10000x10 means array.

Each mean_his array is prepared from an 1D array with the 100 steps. I will exemplify this with a array of ten steps that have to be averaged every two (instead of 1000 every 100):

>>> his_pos = [1,2,3,4,5,6,7,8,9,10]    #the ten positions
>>> history = np.array(his_pos)
>>> history
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
>>> ar2 = np.reshape(history, (-1,2))   # group in two in order to calculate mean
>>> ar2
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10]])
>>> mean_his = ar2.mean(1)
>>> mean_his
array([ 1.5,  3.5,  5.5,  7.5,  9.5])
>>>  

then you append mean_his to means 10000 times and calculate similarly the mean (Note that means have to be initialized outside of the outter loop in order not to be initialized every repetition).

Answer 2

1) Yes, 10000 steps refer to desired accuracy - you have to get the mean number of visited cells at time t = 100, 200 ... 1000 for 10000 random walks. To get the data, you have to accumulate the number of visited cells for each random walk you do (of 10000). to do this, you have to initialize your problem (that is, initialize his_pos and means) outside of p loop. Inside of p loop you should initialize your random walk - get your grid, initial positions and the list you'll write results to. So, problem init will look something like

import scipy as sc
import matplotlib.pyplot as plt

plegma=1000
his_pos=[]  # list which holds the position of the particle in the grid
means=[]    #list which holds the means 

for p in range(10000):
    #-------Initialize problem--------
    in_pos = int(sc.random.randint(0,len(grid),1)) #initial position of particle
    grid=sc.ones(plegma)   # grid full of available positions(ones)    
    his_pos.append([])

After init we need to perform random walk - the i loop. Presently you make just 10 steps of random walk (len(range(0,1000,100)) == 10), but the walk should contain 1000 steps. Hence, the i loop should be

    for i in range(1000):

During the walk you have to mark visited cells somehow. The simplest way is to change grid[in_pos] to 0. Then, every 100th step you need to count the number of visited cells. The way to achieve this is like

        if i % 100 == 0:
            # count the number of 0s in grid and append it to his_pos[p]

Finally, at the end of your 1000 random walks your his_pos will be the (10000*10) list of lists, out of which column-wise means should be taken.

Update:

In order for not to lose information throughout runs, we should append the list where results for p-th run are stored, to the list with all results. The latter is his_pos. To achieve this, we can either append empty list to his_pos and populate it with results during p-th run, or initialize empty list before p-th run and append it to his_pos after p-th run. The algorithm then will look as follows:

#-------Initialize problem--------
plegma=1000
his_pos=[]  # list which holds the number of visited cells in the grid
means=[]    #list which holds the means 

for p in range(10000):
    #-------Initialize run--------
    in_pos = int(sc.random.randint(0,len(grid),1)) #initial position of particle
    grid=sc.ones(plegma)   # grid full of available positions(ones)    
    num_cells = []  # list which holds number of visited cells during run  
    for i in range(1000):
        # make i-th step, get particle position
        # mark particle position on grid as "visited"
        if (i+1) % 100 == 0: # on each 100th step (steps count from 0, thus i+1)
            # count the number of "visited positions" in grid
            # append it to num_cells
    # append num_cells to his_pos
# find column-wise means for his_pos