From Werner KRAUTH

Revision as of 21:42, 22 September 2015 Werner (Talk | contribs) ← Previous diff		Current revision Werner (Talk | contribs)
Line 1:		Line 1:
-	This page presents the program markov_disks_box.py, a Markov-chain algorithm for four disks in a square box of sides 1.	+	This page presents a Python3 implementation of the program event_disks_box.py, a naive event-driven molecular dynamics algorithm for four disks in a square box of sides 1 without periodic boundary conditions. This algorithm was first presented in the SMAC book, and discussed in the present form (in Python2) in my MOOC.
	__FORCETOC__		__FORCETOC__
Line 5:		Line 5:
	=Program=		=Program=
-
-	import random
-
-	L = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]]
-	sigma = 0.15
-	sigma_sq = sigma ** 2
-	delta = 0.1
-	n_steps = 1000
-	for steps in range(n_steps):
-	a = random.choice(L)
-	b = [a[0] + random.uniform(-delta, delta), a[1] + random.uniform(-delta, delta)]
-	min_dist = min((b[0] - c[0]) ** 2 + (b[1] - c[1]) ** 2 for c in L if c != a)
-	box_cond = min(b[0], b[1]) < sigma or max(b[0], b[1]) > 1.0 - sigma
-	if not (box_cond or min_dist < 4.0 * sigma ** 2):
-	a[:] = b
-	print L
-
-	=Version=
-	See history for version information.
-
-	[[Category:Python]]
Line 78:		Line 57:
	vel[a][k] += e_perp[k] * scal		vel[a][k] += e_perp[k] * scal
	vel[b][k] -= e_perp[k] * scal		vel[b][k] -= e_perp[k] * scal
-	print 'event', event	+	print(event', event)
-	print 'time', t	+	print('time', t)
-	print 'pos', pos	+	print('pos', pos)
-	print 'vel', vel	+	print('vel', vel)
		+
		+	=Version=
		+	See history for version information.
		+	For a more elaborate version of this program, see the [https://github.com/jellyfysh/HistoricDisks/blob/master/Python/four-disk/molecular_disks_box.py HistoricDisks] repository connected to our paper [http://www.lps.ens.fr/~krauth/index.php/Li_Nishikawa_et_al_2022 Li et al.: Hard-disk computer simulations -- a historic perspective (2022)]
		+	[[Category:Python]] [[Category:Honnef_2015]] [[Category:MOOC_SMAC]] [[Category:Oxford2025]]

---

Current revision

This page presents a Python3 implementation of the program event_disks_box.py, a naive event-driven molecular dynamics algorithm for four disks in a square box of sides 1 without periodic boundary conditions. This algorithm was first presented in the SMAC book, and discussed in the present form (in Python2) in my MOOC.

Contents 1 Description 2 Program 3 Version

Description

Program

import math

def wall_time(pos_a, vel_a, sigma):
    if vel_a > 0.0:
        del_t = (1.0 - sigma - pos_a) / vel_a
    elif vel_a < 0.0:
        del_t = (pos_a - sigma) / abs(vel_a)
    else:
        del_t = float('inf')
    return del_t

def pair_time(pos_a, vel_a, pos_b, vel_b, sigma):
    del_x = [pos_b[0] - pos_a[0], pos_b[1] - pos_a[1]]
    del_x_sq = del_x[0] ** 2 + del_x[1] ** 2
    del_v = [vel_b[0] - vel_a[0], vel_b[1] - vel_a[1]]
    del_v_sq = del_v[0] ** 2 + del_v[1] ** 2
    scal = del_v[0] * del_x[0] + del_v[1] * del_x[1]
    Upsilon = scal ** 2 - del_v_sq * ( del_x_sq - 4.0 * sigma **2)
    if Upsilon > 0.0 and scal < 0.0:
        del_t = - (scal + math.sqrt(Upsilon)) / del_v_sq
    else:
        del_t = float('inf')
    return del_t

pos = [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]]
vel = [[0.21, 0.12], [0.71, 0.18], [-0.23, -0.79], [0.78, 0.1177]]
singles = [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1)]
pairs = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
sigma = 0.15
t = 0.0
n_events = 100
for event in range(n_events):
    wall_times = [wall_time(pos[k][l], vel[k][l], sigma) for k, l  in singles]
    pair_times = [pair_time(pos[k], vel[k], pos[l], vel[l], sigma) for k, l in pairs]
    next_event = min(wall_times + pair_times)
    t += next_event
    for k, l in singles: pos[k][l] += vel[k][l] * next_event
    if min(wall_times) < min(pair_times):
        collision_disk, direction = singles[wall_times.index(next_event)]
        vel[collision_disk][direction] *= -1.0
    else:
        a, b = pairs[pair_times.index(next_event)]
        del_x = [pos[b][0] - pos[a][0], pos[b][1] - pos[a][1]]
        abs_x = math.sqrt(del_x[0] ** 2 + del_x[1] ** 2)
        e_perp = [c / abs_x for c in del_x]
        del_v = [vel[b][0] - vel[a][0], vel[b][1] - vel[a][1]]
        scal = del_v[0] * e_perp[0] + del_v[1] * e_perp[1]
        for k in range(2):
            vel[a][k] += e_perp[k] * scal
            vel[b][k] -= e_perp[k] * scal
    print(event', event)
    print('time', t)
    print('pos', pos)
    print('vel', vel)

Version

See history for version information. For a more elaborate version of this program, see the HistoricDisks repository connected to our paper Li et al.: Hard-disk computer simulations -- a historic perspective (2022)