Préface

J'ai créé un programme de marche aléatoire d'auto-évitement en python qui est utilisé pour simuler la structure des protéines. Je sens que je peux faire une refonte radicale, mais c'était amusant.

Qu'est-ce que Random Walk?

La marche aléatoire est un mouvement dans lequel le prochain point à déplacer est choisi au hasard et des modèles basés sur une marche aléatoire sont utilisés dans diverses études. Par exemple, le mouvement Brown, célèbre pour avoir été étudié par Einstein, est le mouvement irrégulier de fines particules dans le pollen flottant à la surface de l'eau, qui est également l'un des mouvements qui peuvent être simulés avec un modèle utilisant une marche aléatoire. Le thème de cette fois-ci, la marche aléatoire d'auto-évitement, est une marche aléatoire qui ne reprend pas l'itinéraire que vous avez emprunté. Par exemple, décrivez le mouvement de déplacement aléatoire des points de grille d'une grille rectangulaire bidimensionnelle d'un seul trait. Comme application pratique, des marches aléatoires d'auto-évitement sont parfois utilisées pour simuler la structure des protéines.

J'ai fait un programme de marche aléatoire d'auto-évitement

En raison des propriétés ci-dessus, le programme de marche aléatoire d'auto-évitement est une simulation d'une marche aléatoire lorsque (1) il est nécessaire d'éviter l'itinéraire une fois pris, et (2) il n'y a aucun point qui peut être déplacé de la position actuelle à la suivante (entouré par son propre itinéraire). Doit finir. De plus, (3) la simulation se termine même lorsque la limite de la zone définie est atteinte.

Le programme de marche aléatoire d'auto-évitement sur une grille rectangulaire bidimensionnelle est le suivant. Dans la fonction self_avoidance_random_walk qui renvoie le résultat de la marche aléatoire d'auto-évitement, le around_points_checker qui détermine si les points autour du point actuel sont déjà passés et le around_points_checker qui détermine si le candidat pour le prochain point de mouvement est déjà passé et se déplace s'il n'y a pas de problème. La structure est telle que next_point_decisioner qui détermine fonctionne. (Cette fois, les points en mouvement sont stockés dans la liste à tout moment, donc je pense que c'est un petit rond-point. Il est peut-être possible de créer une chose semblable à une carte et de la diviser en une pièce qui se déplace dessus et une partie qui enregistre la position en mouvement. )

`self_avoidance_random_walk`



import numpy as np
import random

random.seed(None)

'''
Valeur maximale du réseau bidimensionnel xmax,En donnant ymax
Une fonction qui renvoie le résultat d'une marche aléatoire auto-évitante
'''

def self_avoidance_random_walk(xmax,ymax):
    #Préparation de l'état initial.
    list_x = np.array([0]) 
    list_y = np.array([0])
    
    #random_boucle de marche
    roop_num = 0
    while True:
        #Vérifiez la situation autour de votre position actuelle et passez des points(duplicate_num)Compter
        duplicate_num = surrounding_points_checker(roop_num,list_x,list_y)
        
        #Si aucun point ne peut être déplacé, quittez la boucle
        if duplicate_num >= 4:
            break
        
        #Candidat pour le prochain point de déplacement(x_dum, y_dum)Faire
        else:
            D1 = random.randint(0,1)
            D2 = random.randint(0,1)
            dx_dum = (-1)**D1*D2
            dy_dum = (-1)**D1*(1-D2)
            x_dum = list_x[roop_num] + dx_dum
            y_dum = list_y[roop_num] + dy_dum
        
        #Quittez la boucle lorsque vous atteignez la limite
        if (abs(x_dum)==xmax or abs(y_dum)==ymax):
            list_x = np.append(list_x,x_dum)
            list_y = np.append(list_y,y_dum)
            break
        
        #Ajouter de nouveaux points
        roop_num,list_x,list_y = next_point_decisioner(roop_num,list_x,list_y,list_mono,x_dum,y_dum)
        
    return list_x, list_y


def surrounding_points_checker(i,list_x,list_y):
    #Position actuelle x_cur,y_Magasin à cur
    x_cur = list_x[i]
    y_cur = list_y[i]
    
    #X la position autour de la position actuelle_plus,y_plus,x_minus,y_Afficher comme moins
    x_plus  = x_cur+1
    x_minus = x_cur-1
    y_plus  = y_cur+1
    y_minus = y_cur-1
    
    #Enregistrez et renvoyez la position déjà passée
    duplicate_num = 0
    for j in range(len(list_x)):
        if (x_plus == list_x[j] and y_cur == list_y[j]) or (x_minus == list_x[j] and y_cur == list_y[j]):
            duplicate_num +=1
        elif (x_cur == list_x[j] and y_plus == list_y[j]) or (x_cur == list_x[j] and y_minus == list_y[j]):
            duplicate_num +=1
        else:
            duplicate_num +=0
    return duplicate_num


def next_point_decisioner(i,list_x,list_y,list_mono,x_dum,y_dum):
    #Candidats pour déplacer des points(x_dum, y_dum)Déterminez si ce n'est pas un point déjà passé
    k = 0
    for j in range(len(list_x)):
        if (x_dum == list_x[j] and y_dum == list_y[j]):
            k +=1
        else:
            k +=0
    
    #S'il n'est pas passé, il sera ajouté à la liste, et s'il a réussi, le candidat sera rejeté.
    if k == 0:
        list_x = np.append(list_x,x_dum)
        list_y = np.append(list_y,y_dum)
        i+=1
        return i,list_x,list_y
    if k == 1:
        return i,list_x,list_y

Exemple d'exécution d'un programme de marche aléatoire d'auto-évitement

Le programme de marche aléatoire d'auto-évitement est exécuté comme suit, par exemple. Ici, l'axe $ x $ du réseau rectangulaire bidimensionnel est $ -11 \ le x \ le 11 $, et l'axe $ y $ est $ -11 \ le y \ le 11 $.


import matplotlib.pyplot as plt

x_max = 11
y_max = 11

list_x, list_y = self_avoidance_random_walk(x_max, y_max)

plt.figure(figsize=(6, 6))
plt.plot(list_x, list_y)
plt.grid(True)
plt.xlim(-x_max-1,x_max+1)
plt.ylim(-y_max-1,y_max+1)
plt.show()

Ensuite, vous pouvez obtenir le graphique suivant. Vous pouvez voir que la simulation se termine lorsque vous partez du point central et arrivez à la fin ou que vous êtes entouré de vous-même. De plus, le résultat changera de façon aléatoire à chaque exécution.

Résumé

Cette fois, j'ai fait un programme de marche aléatoire d'auto-évitement. Vous pouvez également l'appliquer pour spécifier le type de chose à la position du point de grille et simuler la stabilité énergétique de la structure. En outre, il semble y avoir une méthode de programmation plus efficace, donc j'aimerais en faire un prochain numéro.

[Livres de référence / Web] R.H.Landau, et al. (2018) "Practical Python Library Computational Physics I-Basics of Numerical Computation / HPC / Fourier Wavelet Analysis" (Yoshio Koyanagi, et al.) Asakura Shoten

http://www.orsj.or.jp/~wiki/wiki/index.php/%E3%80%8A%E3%83%A9%E3%83%B3%E3%83%80%E3%83%A0%E3%83%BB%E3%82%A6%E3%82%A9%E3%83%BC%E3%82%AF%E3%81%A8%E3%83%96%E3%83%A9%E3%82%A6%E3%83%B3%E9%81%8B%E5%8B%95%E3%80%8B

J'ai aimé écrire avec un seul trait sur la marche aléatoire d'auto-évitement ~ Utiliser python en référence à la physique computationnelle I (Asakura Shoten) ~