def mcmc_step(box, width, r_cut, r_skin, update_nblist):
# kb = 1.38064852*10**(-13) # N*Å/K (Boltzmann constant)
positions_trial = [np.zeros(box.dimension) for i in range(len(box.positions))]
trial_step = width * np.random.randn(*np.asarray(positions_trial).shape)/4 #randn -> std norm. dist, divide by 4 to keep results mostly within (-0.5, 0.5)
for i in range(len(positions_trial)):
positions_trial[i] = pbc.enforce_pbc(box.positions[i] + trial_step[i], box.size)
particles_trial = [system.Particle(positions_trial[i], box.particles[i].charge,
box.particles[i].sigmaLJ, box.particles[i].epsilonLJ) for i in range(len(box.particles))] # set trial particle list with trial positions
if update_nblist:
particles_trial = neighbourlist.verlet_neighbourlist(particles_trial, r_cut, r_skin) # update neighbourlist for trial positions
else:
for i in range(len(particles_trial)):
particles_trial[i].neighbourlist = box.particles[i].neighbourlist
LJpotential_trial = lennardjones.LJ_potential(particles_trial, r_cut, r_skin)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
acceptance_prob = min(1.0, np.exp(-(LJpotential_trial - box.LJpotential)/box.temp)) # note: potential is actually potential/kb
# if (box_trial.LJpotential>box.LJpotential):
# print("increase = " + repr(box_trial.LJpotential-box.LJpotential))
# print("acceptance prob. = " + repr(acceptance_prob))
# if update_nblist:
# print(acceptance_prob)
if np.random.rand() < acceptance_prob:
return positions_trial, True, trial_step, acceptance_prob # Return True for accepted trial step return trial_step and acceptance_prob to use in unit testing
return box.positions, False, trial_step, acceptance_prob # return False for rejected trial step (no need to update box object)
def create_particle_object(parameters, positions, types):
particles = []
for i in range(len(types)):
position = positions[i]
sigmaLJ = parameters[types[i]][0]
epsilonLJ = parameters[types[i]][1]
charge = parameters[types[i]][3]
particles.append(system.Particle(position, charge, sigmaLJ, epsilonLJ))
return particles
def test_mcmc(dim, n_steps, n_skip, n_reuse_nblist):
# kb = 1.38064852*10**(-13) # N*Å/K (Boltzmann constant)
sigma_argon = 3.405 # Å
epsilon_argon = 119.8 # # actually epsilon/kb (K)
sigma_xenon = 4.07 # Å
epsilon_xenon = 225.3 # actually epsilon/kb (K)
boxsize = np.ones(dim)*np.maximum(sigma_argon, sigma_xenon)*20 # Å
r_c = 2.5*0.5*(sigma_argon+sigma_xenon)
# n_skip = int(n_steps/10)
width = r_c / (n_skip*10)
r_s = 2*n_skip*width
pos1 = pbc.enforce_pbc(np.random.randn(dim), boxsize)
pos2 = pbc.enforce_pbc(pos1 + r_c * np.random.randn(dim), boxsize)
pos3 = pbc.enforce_pbc(pos2 + r_c * np.random.randn(dim), boxsize)
pos4 = pbc.enforce_pbc(pos3 + r_c * np.random.randn(dim), boxsize)
pos5 = pbc.enforce_pbc(pos4 + r_c * np.random.randn(dim), boxsize)
pos6 = pbc.enforce_pbc(pos5 + r_c * np.random.randn(dim), boxsize)
argon_1 = system.Particle(position = pos1, charge = 0, sigmaLJ = sigma_argon, epsilonLJ = epsilon_argon)
argon_2 = system.Particle(position = pos2, charge = 0, sigmaLJ = sigma_argon, epsilonLJ = epsilon_argon)
argon_3 = system.Particle(position = pos3, charge = 0, sigmaLJ = sigma_argon, epsilonLJ = epsilon_argon)
xenon_1 = system.Particle(position = pos4, charge = 0, sigmaLJ = sigma_xenon, epsilonLJ = epsilon_xenon)
xenon_2 = system.Particle(position = pos5, charge = 0, sigmaLJ = sigma_xenon, epsilonLJ = epsilon_xenon)
xenon_3 = system.Particle(position = pos6, charge = 0, sigmaLJ = sigma_xenon, epsilonLJ = epsilon_xenon)
particles = [argon_1, argon_2, argon_3, xenon_1, xenon_2, xenon_3]
temp = 120.0
ourbox = system.Box(dimension = dim, size = boxsize, particles = particles, temp = temp)
ourbox.compute_LJneighbourlist(r_c, r_s)
ourbox.compute_LJ_potential(r_c, r_s)
ourbox.make_positions_list()
ourbox.positions, ourbox.LJpotential, positions_history, potLJ_history, p_acc_vec = metropolis.mcmc(ourbox, n_steps, width, n_skip, n_reuse_nblist, True, r_c, r_s)
ourbox.update_particle_positions()
ourbox.compute_LJneighbourlist(r_c, r_s)
for positions in positions_history:
temp_box = system.Box(dimension = dim, size = boxsize, particles = particles, temp = temp)
for i in range(len(positions_history)):
for j in range(len(temp_box.particles)):
temp_box.particles[j].position = positions_history[i][j]
temp_box.compute_LJ_potential(r_c, r_s)
npt.assert_almost_equal(temp_box.LJpotential, potLJ_history[i], decimal = 3)
def generate_test_system(dim=3,
boxsize=5 * np.ones(3),
nparticles=64,
temp=120,
charge=1,
sigma=1,
epsilon=1,
kb=0.008314462175):
no_of_gridpoints = int(np.cbrt(nparticles)) + 1
g = np.array(
range(-no_of_gridpoints, no_of_gridpoints + 1)
) # generate a list of 3-dimensional pos vectors with combinations of -no_of_gridpoints-1, ...,-1, 0, 1, ..., no_of_gridpoints+1
while g[-1] >= min(boxsize / 2):
g = g / 2
x, y, z = np.meshgrid(g, g, g)
xyz = np.vstack((x.flat, y.flat, z.flat)).T
xyz = np.ascontiguousarray(xyz)
positions = sorted(xyz, key=lambda k: random.random())[0:nparticles]
particles = []
for i in range(nparticles):
particles.append(
system.Particle(position=positions[i],
charge=charge,
sigmaLJ=sigma,
epsilonLJ=epsilon))
testbox = system.Box(dimension=dim,
size=boxsize,
particles=particles,
temp=temp,
kb=kb)
return testbox
fid_reader = csv.reader(fid, delimiter=',', quoting=csv.QUOTE_NONNUMERIC)
for row in fid_reader:
sysconfig.append(row)
for i in range(len(sysconfig)):
sysconfig[i][0:3] = pbc.enforce_pbc(sysconfig[i][0:3]*boxsize, boxsize)
############################################################################################################
# Initialise particle list based on input and the system (ourbox):
############################################################################################################
particles = []
for i in range(len(sysconfig)):
particles.append(system.Particle(position = np.asarray(sysconfig[i][0:3]),
charge = sysconfig[i][3], sigmaLJ = sigma_argon, epsilonLJ = epsilon_argon))
ourbox = system.Box(dimension = dim, size = boxsize, particles = particles, temp = 120.0)
ourbox.compute_LJneighbourlist(r_cut_LJ, r_skin_LJ)
ourbox.compute_LJ_potential(r_cut_LJ, r_skin_LJ)
############################################################################################################
# Simulate system configuration evolution:
############################################################################################################
save_system_history = True
n_opt = 50
# tol_opt = ourbox.size[0]/100
tol_opt = 1/50
ourbox.optimize(n_opt, tol_opt, 5*int(n_steps/n_opt), n_reuse_nblist, n_skip, width, save_system_history, r_cut_LJ, r_skin_LJ)
ourbox.simulate(n_steps, n_reuse_nblist, n_skip, width, save_system_history, r_cut_LJ, r_skin_LJ)
def test_verlet_neighbourlist(dim):
# kb = 1.38064852*10**(-13) # N*Å/K (Boltzmann constant)
sigma_argon = 3.405 # Å
epsilon_argon = 119.8 # actually epsilon/kb (K)
sigma_xenon = 4.07 # Å
epsilon_xenon = 225.3 # actually epsilon/kb (K)
r_c = 2.5 * 0.5 * (sigma_argon + sigma_xenon)
width = r_c / 10
n_skip = 10
r_s = 2 * n_skip * width
boxsize = np.ones(dim) * np.maximum(sigma_argon, sigma_xenon) * 20 # Å
# pos1 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos2 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos3 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos4 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos5 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos6 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
pos1 = pbc.enforce_pbc(np.random.randn(dim), boxsize)
pos2 = pbc.enforce_pbc(pos1 + r_c * np.random.randn(dim), boxsize)
pos3 = pbc.enforce_pbc(pos2 + r_c * np.random.randn(dim), boxsize)
pos4 = pbc.enforce_pbc(pos3 + r_c * np.random.randn(dim), boxsize)
pos5 = pbc.enforce_pbc(pos4 + r_c * np.random.randn(dim), boxsize)
pos6 = pbc.enforce_pbc(pos5 + r_c * np.random.randn(dim), boxsize)
argon_1 = system.Particle(position=pos1,
charge=0,
sigmaLJ=sigma_argon,
epsilonLJ=epsilon_argon)
argon_2 = system.Particle(position=pos2,
charge=0,
sigmaLJ=sigma_argon,
epsilonLJ=epsilon_argon)
argon_3 = system.Particle(position=pos3,
charge=0,
sigmaLJ=sigma_argon,
epsilonLJ=epsilon_argon)
xenon_1 = system.Particle(position=pos4,
charge=0,
sigmaLJ=sigma_xenon,
epsilonLJ=epsilon_xenon)
xenon_2 = system.Particle(position=pos5,
charge=0,
sigmaLJ=sigma_xenon,
epsilonLJ=epsilon_xenon)
xenon_3 = system.Particle(position=pos6,
charge=0,
sigmaLJ=sigma_xenon,
epsilonLJ=epsilon_xenon)
particles = [argon_1, argon_2, argon_3, xenon_1, xenon_2, xenon_3]
ourbox = system.Box(dimension=dim,
size=boxsize,
particles=particles,
temp=120.0)
argon_1.neighbourlist = []
for particlej in [argon_2, argon_3, xenon_1, xenon_2, xenon_3]:
if np.linalg.norm(argon_1.position - particlej.position) < r_c + r_s:
argon_1.neighbourlist.append(particlej)
argon_2.neighbourlist = []
for particlej in [argon_1, argon_3, xenon_1, xenon_2, xenon_3]:
if np.linalg.norm(argon_2.position - particlej.position) < r_c + r_s:
argon_2.neighbourlist.append(particlej)
argon_3.neighbourlist = []
for particlej in [argon_1, argon_2, xenon_1, xenon_2, xenon_3]:
if np.linalg.norm(argon_3.position - particlej.position) < r_c + r_s:
argon_3.neighbourlist.append(particlej)
xenon_1.neighbourlist = []
for particlej in [argon_1, argon_2, argon_3, xenon_2, xenon_3]:
if np.linalg.norm(xenon_1.position - particlej.position) < r_c + r_s:
xenon_1.neighbourlist.append(particlej)
xenon_2.neighbourlist = []
for particlej in [argon_1, argon_2, argon_3, xenon_1, xenon_3]:
if np.linalg.norm(xenon_2.position - particlej.position) < r_c + r_s:
xenon_2.neighbourlist.append(particlej)
xenon_3.neighbourlist = []
for particlej in [argon_1, argon_2, argon_3, xenon_1, xenon_2]:
if np.linalg.norm(xenon_3.position - particlej.position) < r_c + r_s:
xenon_3.neighbourlist.append(particlej)
ourbox.compute_LJneighbourlist(r_c, r_s)
for i in range(len(particles)):
npt.assert_equal(particles[i].neighbourlist,
ourbox.particles[i].neighbourlist)
def plot_neighbourlist():
sigma_argon = 3.405 # Å
epsilon_argon = 119.8 # actually epsilon/kb (K)
sigma_xenon = 4.07 # Å
epsilon_xenon = 225.3 # actually epsilon/kb (K)
r_c = 2.5 * 0.5 * (sigma_argon + sigma_xenon)
width = r_c / 10
n_skip = 10
r_s = 2 * n_skip * width
boxsize = np.ones(2) * np.maximum(sigma_argon, sigma_xenon) * 20 # Å
pos1 = pbc.enforce_pbc(np.random.randn(2), boxsize)
pos2 = pbc.enforce_pbc(pos1 + r_c * np.random.randn(2), boxsize)
pos3 = pbc.enforce_pbc(pos2 + r_c * np.random.randn(2), boxsize)
pos4 = pbc.enforce_pbc(pos3 + r_c * np.random.randn(2), boxsize)
pos5 = pbc.enforce_pbc(pos4 + r_c * np.random.randn(2), boxsize)
pos6 = pbc.enforce_pbc(pos5 + r_c * np.random.randn(2), boxsize)
argon_1 = system.Particle(position=pos1,
charge=0,
sigmaLJ=sigma_argon,
epsilonLJ=epsilon_argon)
argon_2 = system.Particle(position=pos2,
charge=0,
sigmaLJ=sigma_argon,
epsilonLJ=epsilon_argon)
argon_3 = system.Particle(position=pos3,
charge=0,
sigmaLJ=sigma_argon,
epsilonLJ=epsilon_argon)
xenon_1 = system.Particle(position=pos4,
charge=0,
sigmaLJ=sigma_xenon,
epsilonLJ=epsilon_xenon)
xenon_2 = system.Particle(position=pos5,
charge=0,
sigmaLJ=sigma_xenon,
epsilonLJ=epsilon_xenon)
xenon_3 = system.Particle(position=pos6,
charge=0,
sigmaLJ=sigma_xenon,
epsilonLJ=epsilon_xenon)
particles = [argon_1, argon_2, argon_3, xenon_1, xenon_2, xenon_3]
ourbox = system.Box(dimension=2,
size=boxsize,
particles=particles,
temp=120.0)
ourbox.compute_LJneighbourlist(r_c, r_s)
j = 1
nbhood_circle = plt.Circle(ourbox.particles[j].position,
r_c + r_s,
color='b',
fill=False)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_xlim(
(ourbox.center[0] - ourbox.size[0], ourbox.center[0] + ourbox.size[0]))
ax.set_ylim(
(ourbox.center[1] - ourbox.size[1], ourbox.center[1] + ourbox.size[1]))
ax.add_artist(nbhood_circle)
nbpositionsj = [ourbox.particles[j].position]
for particle in ourbox.particles[j].neighbourlist:
nbpositionsj.append(particle.position)
nbpositionsj = np.asarray(nbpositionsj)
print(ourbox.particles[j].neighbourlist)
ax.scatter(*np.asarray(ourbox.positions).T, color="blue")
ax.scatter(*nbpositionsj.T, color="red")
plt.show()
def test_mcmc_step(dim, update_nblist):
# kb = 1.38064852*10**(-13) # N*Å/K (Boltzmann constant)
sigma_argon = 3.405 # Å
epsilon_argon = 119.8 # # actually epsilon/kb (K)
sigma_xenon = 4.07 # Å
epsilon_xenon = 225.3 # actually epsilon/kb (K)
boxsize = np.ones(dim)*np.maximum(sigma_argon, sigma_xenon)*20 # Å
r_c = 2.5*0.5*(sigma_argon+sigma_xenon)
n_skip = 5
width = r_c / (n_skip*10)
r_s = 2*n_skip*width
pos1 = pbc.enforce_pbc(np.random.randn(dim), boxsize)
pos2 = pbc.enforce_pbc(pos1 + r_c * np.random.randn(dim), boxsize)
pos3 = pbc.enforce_pbc(pos2 + r_c * np.random.randn(dim), boxsize)
pos4 = pbc.enforce_pbc(pos3 + r_c * np.random.randn(dim), boxsize)
pos5 = pbc.enforce_pbc(pos4 + r_c * np.random.randn(dim), boxsize)
pos6 = pbc.enforce_pbc(pos5 + r_c * np.random.randn(dim), boxsize)
argon_1 = system.Particle(position = pos1, charge = 0, sigmaLJ = sigma_argon, epsilonLJ = epsilon_argon)
argon_2 = system.Particle(position = pos2, charge = 0, sigmaLJ = sigma_argon, epsilonLJ = epsilon_argon)
argon_3 = system.Particle(position = pos3, charge = 0, sigmaLJ = sigma_argon, epsilonLJ = epsilon_argon)
xenon_1 = system.Particle(position = pos4, charge = 0, sigmaLJ = sigma_xenon, epsilonLJ = epsilon_xenon)
xenon_2 = system.Particle(position = pos5, charge = 0, sigmaLJ = sigma_xenon, epsilonLJ = epsilon_xenon)
xenon_3 = system.Particle(position = pos6, charge = 0, sigmaLJ = sigma_xenon, epsilonLJ = epsilon_xenon)
particles = [argon_1, argon_2, argon_3, xenon_1, xenon_2, xenon_3]
temp = 120.0
ourbox = system.Box(dimension = dim, size = boxsize, particles = particles, temp = temp)
ourbox.compute_LJneighbourlist(r_c, r_s)
ourbox.compute_LJ_potential(r_c, r_s)
ourbox.make_positions_list()
ourbox_trial = copy.deepcopy(ourbox)
ourbox_post_mcmc_step = system.Box(dimension = dim, size = boxsize, particles = particles, temp = temp)
ourbox_post_mcmc_step.compute_LJneighbourlist(r_c, r_s)
ourbox_post_mcmc_step.compute_LJ_potential(r_c, r_s)
ourbox_post_mcmc_step.make_positions_list()
ourbox_post_mcmc_step.positions, ourbox_post_mcmc_step.LJpotential, trial_step, _ = metropolis.mcmc_step(ourbox, width, r_c, r_s, update_nblist)
ourbox_post_mcmc_step.update_particle_positions()
ourbox_post_mcmc_step.compute_LJneighbourlist(r_c, r_s)
for i, particle in enumerate(ourbox_trial.particles):
ourbox_trial.particles[i].position = pbc.enforce_pbc(ourbox_trial.particles[i].position + trial_step[i], ourbox_trial.size)
ourbox_trial.make_positions_list()
ourbox_trial.compute_LJ_potential(r_c, r_s)
if update_nblist:
ourbox_trial.compute_LJneighbourlist(r_c, r_s)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
prob_accept = np.minimum(1, np.exp(-(ourbox_trial.LJpotential - ourbox.LJpotential)/temp))
if np.random.rand() < prob_accept:
return ourbox_trial, ourbox_post_mcmc_step
else:
return ourbox, ourbox_post_mcmc_step
def gen_test_box(dim):
# kb = 1.38064852*10**(-13) # N*Å/K (Boltzmann constant)
sigma_argon = 3.405 # Å
epsilon_argon = 119.8 # actually epsilon/kb (K)
sigma_xenon = 4.07 # Å
epsilon_xenon = 225.3 # actually epsilon/kb (K)
boxsize = np.ones(dim) * np.maximum(sigma_argon, sigma_xenon) * 20
r_c = 2.5 * 0.5 * (sigma_argon + sigma_xenon)
n_skip = 5
width = r_c / (n_skip * 10)
r_s = 2 * n_skip * width
# pos1 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos2 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos3 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos4 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos5 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
# pos6 = pbc.enforce_pbc(np.random.randn(dim)/4, boxsize)
pos1 = pbc.enforce_pbc(np.random.randn(dim), boxsize)
pos2 = pbc.enforce_pbc(pos1 + r_c * np.random.randn(dim), boxsize)
pos3 = pbc.enforce_pbc(pos2 + r_c * np.random.randn(dim), boxsize)
pos4 = pbc.enforce_pbc(pos3 + r_c * np.random.randn(dim), boxsize)
pos5 = pbc.enforce_pbc(pos4 + r_c * np.random.randn(dim), boxsize)
pos6 = pbc.enforce_pbc(pos5 + r_c * np.random.randn(dim), boxsize)
argon_1 = system.Particle(position=pos1,
charge=0,
sigmaLJ=sigma_argon,
epsilonLJ=epsilon_argon)
argon_2 = system.Particle(position=pos2,
charge=0,
sigmaLJ=sigma_argon,
epsilonLJ=epsilon_argon)
argon_3 = system.Particle(position=pos3,
charge=0,
sigmaLJ=sigma_argon,
epsilonLJ=epsilon_argon)
xenon_1 = system.Particle(position=pos4,
charge=0,
sigmaLJ=sigma_xenon,
epsilonLJ=epsilon_xenon)
xenon_2 = system.Particle(position=pos5,
charge=0,
sigmaLJ=sigma_xenon,
epsilonLJ=epsilon_xenon)
xenon_3 = system.Particle(position=pos6,
charge=0,
sigmaLJ=sigma_xenon,
epsilonLJ=epsilon_xenon)
particles = [argon_1, argon_2, argon_3, xenon_1, xenon_2, xenon_3]
return system.Box(dimension=dim,
size=boxsize,
particles=particles,
temp=120.0)
