Vorwort

Ich habe ein Selbstvermeidungs-Random-Walk-Programm in Python erstellt, das zur Simulation der Struktur von Proteinen verwendet wird. Ich habe das Gefühl, dass ich eine grundlegende Überarbeitung vornehmen kann, aber es hat Spaß gemacht.

Was ist Random Walk?

Ein zufälliger Spaziergang ist eine Übung, bei der der nächste zu bewegende Punkt zufällig ausgewählt wird und Modelle, die auf dem zufälligen Spaziergang basieren, in verschiedenen Studien verwendet werden. Zum Beispiel ist die Brown-Bewegung, die berühmt dafür ist, von Einstein untersucht zu werden, die unregelmäßige Bewegung feiner Partikel in Pollen, die auf der Wasseroberfläche schwimmen. Dies ist auch eine der Bewegungen, die mit einem Modell unter Verwendung eines zufälligen Spaziergangs simuliert werden können. Das Thema dieser Zeit, Selbstvermeidungs-Zufallsspaziergang, ist ein Zufallsspaziergang, der nicht den Weg nimmt, den Sie erneut genommen haben. Beschreiben Sie beispielsweise die Bewegung des zufälligen Verschiebens der Gitterpunkte eines zweidimensionalen rechteckigen Gitters mit einem einzigen Strich. Als praktische Anwendung werden manchmal zufällige Spaziergänge zur Selbstvermeidung verwendet, um die Struktur von Proteinen zu simulieren.

Ich habe ein Selbstvermeidungsprogramm für zufällige Spaziergänge gemacht

Aufgrund der obigen Eigenschaften ist das Selbstvermeidungs-Zufallslaufprogramm eine Simulation eines Zufallslaufs, wenn (1) die einmal genommene Route vermieden werden muss und (2) kein Punkt von der aktuellen Position zur nächsten verschoben werden kann (umgeben von einer eigenen Route). Muss enden. (3) Die Simulation endet auch dann, wenn die Grenze des eingestellten Bereichs erreicht ist.

Das Programm zur zufälligen Vermeidung von Selbstvermeidungen auf einem zweidimensionalen rechteckigen Gitter lautet wie folgt. In der Funktion self_avoidance_random_walk, die das Ergebnis eines zufälligen Spaziergangs zur Selbstvermeidung zurückgibt, bestimmt der Surrounding_Points_checker, ob die Punkte um den aktuellen Punkt bereits bestanden wurden, und der Surrounding_Points_checker, der feststellt, ob der Kandidat für den nächsten Bewegungspunkt bereits bestanden hat, und bewegt sich, wenn kein Problem vorliegt. Die Struktur ist so, dass next_point_decisioner, der bestimmt, funktioniert. (Dieses Mal werden die sich bewegenden Punkte jederzeit in der Liste gespeichert, daher halte ich es für einen kleinen Kreisverkehr. Es kann möglich sein, ein kartenähnliches Objekt zu erstellen und es in ein sich bewegendes Teil und einen Teil zu unterteilen, der die sich bewegende Position aufzeichnet. )

`self_avoidance_random_walk`



import numpy as np
import random

random.seed(None)

'''
Maximalwert des zweidimensionalen Gitters xmax,Indem ich ymax gebe
Eine Funktion, die das Ergebnis eines selbstvermeidenden Zufallslaufs zurückgibt
'''

def self_avoidance_random_walk(xmax,ymax):
    #Vorbereitung des Ausgangszustandes.
    list_x = np.array([0]) 
    list_y = np.array([0])
    
    #random_Gehschleife
    roop_num = 0
    while True:
        #Überprüfen Sie die Situation um Ihren aktuellen Standort und passieren Sie Punkte(duplicate_num)Anzahl
        duplicate_num = surrounding_points_checker(roop_num,list_x,list_y)
        
        #Wenn kein Punkt verschoben werden kann, verlassen Sie die Schleife
        if duplicate_num >= 4:
            break
        
        #Kandidat für den nächsten Zugpunkt(x_dum, y_dum)Zu machen
        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
        
        #Verlassen Sie die Schleife, wenn Sie die Grenze erreichen
        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
        
        #Neue Punkte hinzufügen
        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):
    #Aktuelle Position x_cur,y_In cur lagern
    x_cur = list_x[i]
    y_cur = list_y[i]
    
    #X die Position um die aktuelle Position_plus,y_plus,x_minus,y_Als Minus anzeigen
    x_plus  = x_cur+1
    x_minus = x_cur-1
    y_plus  = y_cur+1
    y_minus = y_cur-1
    
    #Notieren Sie die bereits übergebene Position und geben Sie sie zurück
    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):
    #Kandidaten für bewegliche Punkte(x_dum, y_dum)Stellen Sie fest, ob es sich nicht um einen Punkt handelt, der bereits überschritten wurde
    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
    
    #Wenn es nicht bestanden hat, wird es der Liste hinzugefügt, und wenn es bestanden hat, wird der Kandidat abgelehnt.
    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

Beispiel für die Ausführung eines Random-Walk-Programms zur Selbstvermeidung

Das Random-Walk-Programm zur Selbstvermeidung wird beispielsweise wie folgt ausgeführt. Hier ist die $ x $ -Achse des zweidimensionalen rechteckigen Gitters $ -11 \ le x \ le 11 $, und die $ y $ -Achse ist $ -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()

Dann können Sie das folgende Diagramm erhalten. Sie können sehen, dass die Simulation endet, wenn Sie vom Mittelpunkt beginnen und bis zum Ende kommen oder von sich selbst umgeben sind. Außerdem ändert sich das Ergebnis bei jedem Lauf zufällig.

Zusammenfassung

Dieses Mal habe ich ein Selbstvermeidungsprogramm für zufällige Spaziergänge gemacht. Sie können dies auch anwenden, um den Typ des Objekts an der Position des Gitterpunkts anzugeben und die Energiestabilität der Struktur zu simulieren. Außerdem scheint es eine effizientere Programmiermethode zu geben, daher möchte ich sie zu einem zukünftigen Thema machen.

[Nachschlagewerke / Web] R. H. Landau et al. (2018) "Praktische Python-Bibliothek Computerphysik I-Grundlagen der numerischen Berechnung / HPC / Fourier-Wavelet-Analyse" (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

Ich habe es genossen, mit einem einzigen Strich auf dem Selbstvermeidungs-Zufallslauf zu schreiben ~ Mit Python in Bezug auf Computational Physics I (Asakura Shoten) ~