def setUp(self):
np.random.seed(42)
self.L_mobile = 4
self.L_total = self.L_mobile + 2
self.nr_particles_mobile = self.L_mobile * self.L_mobile
self.nr_particles_total = self.L_total * self.L_total
self.nr_particles_frozen = self.nr_particles_total - self.nr_particles_mobile
self.box_dimension = 2
self.ndof = self.nr_particles_total * self.box_dimension
self.n_frozen_dof = self.nr_particles_frozen * self.box_dimension
self.frozen_dof = []
self.frozen_atoms = []
for particle_index in range(self.nr_particles_total):
xmean = int(particle_index % self.L_total)
ymean = int(particle_index / self.L_total)
if ymean == 0 or ymean == self.L_total - 1 or xmean == 0 or xmean == self.L_total - 1:
self.frozen_dof.append(particle_index * self.box_dimension)
self.frozen_dof.append(particle_index * self.box_dimension + 1)
self.frozen_atoms.append(particle_index)
self.eps = 1
self.x = np.zeros(self.ndof)
for p in range(self.nr_particles_total):
xmean = int(p % self.L_total)
ymean = int(p / self.L_total)
self.x[p * self.box_dimension] = xmean + 0.1 * np.random.rand()
self.x[p * self.box_dimension + 1] = ymean + 0.1 * np.random.rand()
self.radii = np.asarray([0.3 + 0.01 * np.random.rand() for _ in range(self.nr_particles_total)])
self.sca = 1
self.rcut = 2 * (1 + self.sca) * np.amax(self.radii)
self.boxvec = (self.L_total + self.rcut) * np.ones(self.box_dimension)
self.pot_cells_N_frozen_N = HS_WCA(eps=self.eps, sca=self.sca,
radii=self.radii, ndim=self.box_dimension,
boxvec=self.boxvec, use_periodic=True,
use_frozen=False, use_cell_lists=False)
self.pot_cells_Y_frozen_N = HS_WCA(eps=self.eps, sca=self.sca,
radii=self.radii, ndim=self.box_dimension,
boxvec=self.boxvec, use_periodic=True,
use_frozen=False, use_cell_lists=True,
reference_coords=self.x, rcut=self.rcut)
self.pot_cells_N_frozen_Y = HS_WCA(eps=self.eps, sca=self.sca,
radii=self.radii, ndim=self.box_dimension,
boxvec=self.boxvec, use_periodic=True,
use_frozen=True, use_cell_lists=False,
frozen_atoms=self.frozen_atoms,
reference_coords=self.x)
self.pot_cells_Y_frozen_Y = HS_WCA(eps=self.eps, sca=self.sca,
radii=self.radii, ndim=self.box_dimension,
boxvec=self.boxvec, use_periodic=True,
use_frozen=True, use_cell_lists=True,
reference_coords=self.x,
frozen_atoms=self.frozen_atoms, rcut=self.rcut)
self.x_red = []
for atom in range(self.nr_particles_total):
if atom not in self.frozen_atoms:
self.x_red.extend(self.x[atom * self.box_dimension : (atom + 1) * self.box_dimension])
self.opt_NN = ModifiedFireCPP(self.x, self.pot_cells_N_frozen_N)
self.opt_YN = ModifiedFireCPP(self.x, self.pot_cells_Y_frozen_N)
self.opt_NY = ModifiedFireCPP(self.x_red, self.pot_cells_N_frozen_Y)
self.opt_YY = ModifiedFireCPP(self.x_red, self.pot_cells_Y_frozen_Y)
def __init__(self, nparticles_x, amplitude):
self.ndim = 2
self.LX = nparticles_x
self.LY = self.LX
self.nparticles_x = nparticles_x
self.N = self.nparticles_x ** self.ndim
self.dof = self.ndim * self.N
self.amplitude = amplitude
self.x = np.zeros(self.dof)
for particle in range(self.N):
pid = self.ndim * particle
self.x[pid] = particle % self.LX
self.x[pid + 1] = int(particle / self.LX)
self.x_initial = np.asarray([xi + np.random.uniform(- self.amplitude, self.amplitude) for xi in self.x])
self.x_initial = np.reshape(self.x_initial, (self.N,2))
self.x_initial[:,0] -= np.mean(self.x_initial[:,0])
self.x_initial[:,1] -= np.mean(self.x_initial[:,1])
self.x_initial = self.x_initial.flatten()
#self.radius = 0.3
#self.sca = 1.5
self.radius = 0.25
self.sca = 1.8
self.radii = np.ones(self.N) * self.radius
self.eps = 1.0
self.boxvec = np.array([self.LX, self.LY])
self.potential = HS_WCA(use_periodic=use_periodic, eps=self.eps,
sca=self.sca, radii=self.radii.copy(), ndim=self.ndim, boxvec=self.boxvec.copy())
self.potential_ = HS_WCA(use_periodic=use_periodic, eps=self.eps,
sca=self.sca, radii=self.radii.copy(), ndim=self.ndim, boxvec=self.boxvec.copy())
self.rcut = 2 * (1 + self.sca) * self.radius
self.ncellx_scale = 1
self.potential_cells = HS_WCA(use_periodic=use_periodic,
use_cell_lists=True, eps=self.eps,
sca=self.sca, radii=self.radii.copy(),
boxvec=self.boxvec.copy(),
rcut=self.rcut, ndim=self.ndim,
ncellx_scale=self.ncellx_scale)
self.potential_cells_ = HS_WCA(use_periodic=use_periodic,
use_cell_lists=True, eps=self.eps,
sca=self.sca, radii=self.radii.copy(),
boxvec=self.boxvec.copy(),
rcut=self.rcut, ndim=self.ndim,
ncellx_scale=self.ncellx_scale)
self.tol = 1e-7
self.maxstep = np.amax(self.radii)
self.nstepsmax = int(1e6)
assert(self.boxvec[0]==self.boxvec[1])
print("x_initial energy:", self.potential.getEnergy(self.x_initial))
print("x_initial cells energy:", self.potential_cells.getEnergy(self.x_initial))
assert(self.potential.getEnergy(self.x_initial) == self.potential_.getEnergy(self.x_initial))
assert(self.potential_cells.getEnergy(self.x_initial) == self.potential_cells_.getEnergy(self.x_initial))
#assert abs(self.potential.getEnergy(self.x_initial) - self.potential_cells.getEnergy(self.x_initial)) < 1e-10
assert np.allclose(self.potential.getEnergy(self.x_initial), self.potential_cells.getEnergy(self.x_initial), rtol=1e-10)
print(self.boxvec)
def __init__(self,
nr_particles=42,
hard_volume_fraction=0.5,
epsilon=1,
alpha=0.2):
np.random.seed(42)
self.nr_particles = nr_particles
self.hard_volume_fraction = hard_volume_fraction
self.epsilon = epsilon
self.alpha = alpha
self.hard_radii = np.random.normal(loc=1,
scale=0.1,
size=self.nr_particles)
self.box_length = np.power(
np.sum(np.asarray([4 * np.pi * r**3 / 3
for r in self.hard_radii])) /
self.hard_volume_fraction, 1 / 3)
self.nr_dof = 3 * self.nr_particles
self.x = np.random.uniform(-0.5 * self.box_length,
0.5 * self.box_length, self.nr_dof)
self.box_vector = np.ones(3) * self.box_length
self.rcut = 2 * (1 + alpha) * np.amax(self.hard_radii)
self.potential = HS_WCA(use_periodic=True,
use_cell_lists=False,
eps=self.epsilon,
sca=self.alpha,
radii=self.hard_radii,
boxvec=self.box_vector,
rcut=self.rcut)
self.optimizer = LBFGS_CPP(self.x, self.potential)
print "energy before:", self.potential.getEnergy(self.x)
self.optimizer.run()
print "minimization converged", self.optimizer.get_result().success
print "energy after:", self.potential.getEnergy(
self.optimizer.get_result().coords)
def FindMinimumHSWCA(foldname):
""" Finds the true minimum corresponding:
Note Gradient Descent step should be adequately small for this to work
"""
foldpath = BASE_DIRECTORY + "/" + foldname
sysparams = load_params(foldpath)
(hs_radii, initial_coords, box_length) = load_secondary_params(foldpath)
box_length = float(box_length)
boxv = [box_length] * sysparams.ndim.value
potential = HS_WCA(
use_cell_lists=False,
eps=sysparams.eps.value,
sca=sysparams.pot_sca.value,
radii=hs_radii * sysparams.radius_sca.value,
boxvec=boxv,
ndim=sysparams.ndim.value,
distance_method=Distance.PERIODIC,
)
# ret = steepest_descent(initial_coords, potential)
# ret = fire(initial_coords, potential, iprint=1)
# E, V = print(potential.getEnergyGradient(initial_coords))
# ret = quench_mixed_optimizer(potential, initial_coords, conv_tol=1e-100)
ret = quench_mixed_optimizer(potential,
initial_coords,
conv_tol=0,
nsteps=1000)
# ret = quench_steepest(potential, initial_coords, stepsize=0.05, nsteps=2000)
print(ret.nsteps)
print(ret.nfev)
np.savetxt(foldpath + "/trueminimum.txt", ret.coords, delimiter=",")
def test_same_minima_HS_WCA(self):
nparticles = 32
radius_sca = 0.9085602964160698
pot_sca = 0.1
eps = 1.0
hs_radii = 0.05 * np.random.randn(nparticles) + 1
volpart = np.sum(4. / 3. * np.pi * hs_radii**3)
phi = 0.7
boxl = (volpart / phi)**(1 / 3.)
boxv = [boxl, boxl, boxl]
coords = np.random.rand(nparticles * 3) * boxl
ncellx_scale = get_ncellsx_scale(np.ones(nparticles), boxv)
bdim = 3
distance_method = Distance.PERIODIC
pot_cellists = HS_WCA(use_cell_lists=True,
eps=eps,
sca=pot_sca,
radii=hs_radii * radius_sca,
boxvec=boxv,
ndim=bdim,
ncellx_scale=ncellx_scale,
distance_method=distance_method)
pot_no_cellists = HS_WCA(use_cell_lists=False,
eps=eps,
sca=pot_sca,
radii=hs_radii * radius_sca,
boxvec=boxv,
ndim=bdim,
ncellx_scale=ncellx_scale,
distance_method=distance_method)
nsteps = 1000
tol = 1e-5
res_cell_lists = lbfgs_cpp(coords,
pot_cellists,
nsteps=nsteps,
tol=tol)
res_no_cell_lists = lbfgs_cpp(coords,
pot_no_cellists,
nsteps=nsteps,
tol=tol)
fcoords_cell_lists = res_cell_lists.coords
fcoords_no_cell_lists = res_no_cell_lists.coords
# self.assertEqual(fcoords_no_cell_lists,fcoords_cell_lists)
self.assertTrue(np.all(fcoords_no_cell_lists == fcoords_cell_lists))
def __init__(self, nparticles_x, amplitude):
self.ndim = 2
self.LX = nparticles_x
self.LY = self.LX
self.nparticles_x = nparticles_x
self.N = self.nparticles_x**self.ndim
self.amplitude = amplitude
self.dof = self.ndim * self.N
self.x = np.zeros(self.dof)
self.frozen_atoms = []
for particle in xrange(self.N):
pid = self.ndim * particle
xcoor = particle % self.LX
ycoor = int(particle / self.LX)
self.x[pid] = xcoor
self.x[pid + 1] = ycoor
if xcoor == 0 or xcoor == self.LX - 1 or ycoor == 0 or ycoor == self.LY - 1:
self.frozen_atoms.append(particle)
self.x_initial = copy.copy(self.x)
for particle in xrange(self.N):
if particle not in self.frozen_atoms:
pid = self.ndim * particle
self.x_initial[pid] += np.random.uniform(
-self.amplitude, self.amplitude)
self.x_initial[pid + 1] += np.random.uniform(
-self.amplitude, self.amplitude)
self.x_initial = np.reshape(self.x_initial, (self.N, 2))
self.x_initial[:, 0] -= np.mean(self.x_initial[:, 0])
self.x_initial[:, 1] -= np.mean(self.x_initial[:, 1])
self.x_initial = self.x_initial.flatten()
min_x = np.amin(self.x_initial)
if min_x < 0:
self.x_initial -= min_x
#self.radius = 0.3
#self.sca = 1.5
self.radius = 0.25
self.sca = 1.8
self.radii = np.ones(self.N) * self.radius
self.eps = 1.0
max_edge = np.amax([
np.amax(self.x_initial),
np.abs(np.amin(self.x_initial))
]) + 2 * self.amplitude + (1 + self.sca) * self.radius
self.boxvec = np.array([max_edge, max_edge])
self.frozen_atoms1 = np.array(self.frozen_atoms)
self.frozen_atoms2 = np.array(self.frozen_atoms)
print "self.frozen_atoms1", self.frozen_atoms1
self.potential = HS_WCA(use_frozen=True,
use_periodic=use_periodic_frozen,
reference_coords=self.x_initial,
frozen_atoms=self.frozen_atoms1,
eps=self.eps,
sca=self.sca,
radii=self.radii,
ndim=self.ndim,
boxvec=self.boxvec)
self.rcut = 2 * (1 + self.sca) * self.radius
self.ncellx_scale = 1.0
self.potential_cells = HS_WCA(use_frozen=True,
use_periodic=use_periodic_frozen,
use_cell_lists=True,
eps=self.eps,
sca=self.sca,
radii=self.radii,
boxvec=self.boxvec,
reference_coords=self.x_initial,
rcut=self.rcut,
ndim=self.ndim,
ncellx_scale=self.ncellx_scale,
frozen_atoms=self.frozen_atoms2)
self.tol = 1e-7
self.maxstep = np.amax(self.radii)
self.nstepsmax = int(1e6)
assert (self.boxvec[0] == self.boxvec[1])
self.x_initial_red = reduce_coordinates(self.x_initial,
self.frozen_atoms, self.ndim)
print "x_initial energy:", self.potential.getEnergy(self.x_initial_red)
print "x_initial cells energy:", self.potential_cells.getEnergy(
self.x_initial_red)
#assert abs(self.potential.getEnergy(self.x_initial_red) - self.potential_cells.getEnergy(self.x_initial_red)) < 1e-10
assert np.allclose(self.potential.getEnergy(self.x_initial_red),
self.potential_cells.getEnergy(self.x_initial_red),
rtol=1e-10)
print self.boxvec
def __init__(self,
boxdim=2,
nr_particles=100,
hard_phi=0.4,
nr_steps=1e6,
epsilon=1,
alpha=0.1,
verbose=False):
# Settings.
np.random.seed(42)
# Input parameters.
self.boxdim = boxdim
self.nr_particles = nr_particles
self.hard_phi = hard_phi
self.nr_steps = nr_steps
self.epsilon = epsilon
self.alpha = alpha
self.verbose = verbose
# Derived quantities.
self.hard_radii = np.ones(self.nr_particles)
def volume_nball(radius, n):
return np.power(np.pi, n / 2) * np.power(radius,
n) / gamma(n / 2 + 1)
self.box_length = np.power(
np.sum(
np.asarray(
[volume_nball(r, self.boxdim)
for r in self.hard_radii])) / self.hard_phi,
1 / self.boxdim)
self.box_vector = np.ones(self.boxdim) * self.box_length
# HS-WCA potential.
self.potential = HS_WCA(use_periodic=True,
use_cell_lists=True,
ndim=self.boxdim,
eps=self.epsilon,
sca=self.alpha,
radii=self.hard_radii,
boxvec=self.box_vector)
# Initial configuration by minimization.
self.nr_dof = self.boxdim * self.nr_particles
self.x = np.random.uniform(-0.5 * self.box_length,
0.5 * self.box_length, self.nr_dof)
optimizer = LBFGS_CPP(self.x, self.potential)
optimizer.run()
if not optimizer.get_result().success:
print("warning: minimization has not converged")
self.x = optimizer.get_result().coords.copy()
# Potential and MC rules.
self.temperature = 1
self.mc = MC(self.potential, self.x, self.temperature, self.nr_steps)
self.step = RandomCoordsDisplacement(42,
1,
single=True,
nparticles=self.nr_particles,
bdim=self.boxdim)
if self.verbose:
print("initial MC stepsize")
print self.step.get_stepsize()
self.mc.set_takestep(self.step)
self.eq_steps = self.nr_steps / 2
self.mc.set_report_steps(self.eq_steps)
self.gr_quench = RecordPairDistHistogram(self.box_vector,
50,
self.eq_steps,
self.nr_particles,
optimizer=optimizer)
self.gr = RecordPairDistHistogram(self.box_vector, 50, self.eq_steps,
self.nr_particles)
self.mc.add_action(self.gr_quench)
self.mc.add_action(self.gr)
self.test = MetropolisTest(44)
self.mc.add_accept_test(self.test)
