class TestNS_LJ(unittest.TestCase):
def setUp(self):
self.setUp1()
def compute_cv(self, Tmin=.01, Tmax=3., nT=100):
T = np.arange(Tmin, Tmax, (Tmax - Tmin) / nT)
Cv = compute_cv_c(np.array(self.ns.max_energies),
float(self.nproc), float(self.ndof), T.min(), T.max(), T.size, float(self.ndof), live=False)
return T, Cv
def set_up_system(self):
self.natoms = 13
self.gmin = -44.3269
self.system = LJClusterSENS(self.natoms, 2.5)
self.ndof = 3 * self.natoms - 6
def setUp1(self, nproc=1):
self.set_up_system()
self.nreplicas = 10
self.stepsize = 0.01
self.nproc = nproc
self.mc_runner = self.system.get_mc_walker(mciter=100)
self.ns = NestedSampling(self.system, self.nreplicas, self.mc_runner,
stepsize=0.1, nproc=nproc, verbose=False)
self.Emax0 = self.ns.replicas[-1].energy
self.niter = 100
for i in xrange(self.niter):
self.ns.one_iteration()
self.Emax = self.ns.replicas[-1].energy
self.Emin = self.ns.replicas[0].energy
def test1(self):
self.assert_(len(self.ns.replicas) == self.nreplicas)
self.assert_(self.Emax < self.Emax0)
self.assert_(self.Emin < self.Emax)
self.assert_(self.Emin < 0)
self.assert_(self.Emin >= self.gmin)
self.assert_(self.ns.stepsize != self.stepsize)
self.assertEqual(len(self.ns.max_energies), self.niter * self.nproc)
self.assertEqual(self.ns.failed_mc_walks, 0)
def run_ns(self, max_iter=100, Etol=1e-4):
# max_iter = 10000
# self.Etol = .01
self.Etol = Etol
for i in xrange(int(max_iter)):
self.ns.one_iteration()
deltaE = self.ns.replicas[-1].energy - self.ns.replicas[0].energy
if deltaE < self.Etol:
break
self.niter = i + 1
self.Emax = self.ns.replicas[-1].energy
self.Emin = self.ns.replicas[0].energy
def do_nested_sampling(nreplicas=10, niter=200, mciter=1000, stepsize=.8, estop=-.9,
x0=[1,1], r0=2,
xlim=None, ylim=None, circle=False
):
path = []
def mc_record_position_event(coords=None, **kwargs):
if len(path) == 0 or not np.all(path[-1] == coords):
path.append(coords)
p = Pot()
print p.get_energy(np.array([1,2.]))
mc_walker = MonteCarloWalker(p, mciter=mciter, events=[mc_record_position_event])
# initialize the replicas with random positions
replicas = []
for i in xrange(nreplicas):
# choose points uniformly in a circle
if circle:
coords = vector_random_uniform_hypersphere(2) * r0 + x0
else:
coords = np.zeros(2)
coords[0] = np.random.uniform(xlim[0], xlim[1])
coords[1] = np.random.uniform(ylim[0], ylim[1])
# coords = np.random.uniform(-1,3,size=2)
r = Replica(coords, p.get_energy(coords))
replicas.append(r)
ns = NestedSampling(replicas, mc_walker, stepsize=stepsize)
results = [Result()]
results[0].replicas = [r.copy() for r in replicas]
for i in xrange(niter):
ns.one_iteration()
new_res = Result()
new_res.replicas = [r.copy() for r in replicas]
new_res.starting_replica = ns.starting_replicas[0].copy()
new_res.new_replica = ns.new_replicas[0].copy()
path.insert(0, new_res.starting_replica.x)
new_res.mc_path = path
results.append(new_res)
path = []
if ns.replicas[-1].energy < estop:
break
# plt.plot(ns.max_energies)
# plt.show()
return ns, results
class TestNS(unittest.TestCase):
"""to test distributed computing must start a dispatcher with --server-name test and --port 9090
"""
def setUp(self):
self.setUp1()
def setUp1(self, nproc=1, multiproc=True):
self.ndim = 3
self.harmonic = Harmonic(self.ndim)
self.nreplicas = 10
self.stepsize = 0.1
self.nproc = nproc
self.mc_runner = MonteCarloWalker(self.harmonic, mciter=40)
if multiproc == False:
hostname = socket.gethostname()
host = Pyro4.socketutil.getIpAddress(hostname, workaround127=True)
self.dispatcher_URI = "PYRO:" + "test@" + host + ":9090"
else:
self.dispatcher_URI = None
replicas = []
for i in range(self.nreplicas):
x = self.harmonic.get_random_configuration()
replicas.append(Replica(x, self.harmonic.get_energy(x)))
self.ns = NestedSampling(replicas,
self.mc_runner,
stepsize=0.1,
nproc=nproc,
verbose=False,
dispatcher_URI=self.dispatcher_URI)
self.Emax0 = self.ns.replicas[-1].energy
self.niter = 100
for i in range(self.niter):
self.ns.one_iteration()
self.Emax = self.ns.replicas[-1].energy
self.Emin = self.ns.replicas[0].energy
def test1(self):
print("running TestNS")
self.assert_(len(self.ns.replicas) == self.nreplicas)
self.assert_(self.Emax < self.Emax0)
self.assert_(self.Emin < self.Emax)
self.assert_(self.Emin >= 0)
self.assert_(self.ns.stepsize != self.stepsize)
self.assertEqual(len(self.ns.max_energies), self.niter * self.nproc)
class TestNS(unittest.TestCase):
"""to test distributed computing must start a dispatcher with --server-name test and --port 9090
"""
def setUp(self):
self.setUp1()
def setUp1(self, nproc=1, multiproc=True):
self.ndim = 3
self.harmonic = Harmonic(self.ndim)
self.nreplicas = 10
self.stepsize = 0.1
self.nproc = nproc
self.mc_runner = MonteCarloWalker(self.harmonic, mciter=40)
if multiproc == False:
hostname=socket.gethostname()
host = Pyro4.socketutil.getIpAddress(hostname, workaround127=True)
self.dispatcher_URI = "PYRO:"+"test@"+host+":9090"
else:
self.dispatcher_URI = None
replicas = []
for i in xrange(self.nreplicas):
x = self.harmonic.get_random_configuration()
replicas.append(Replica(x, self.harmonic.get_energy(x)))
self.ns = NestedSampling(replicas, self.mc_runner,
stepsize=0.1, nproc=nproc, verbose=False, dispatcher_URI=self.dispatcher_URI)
self.Emax0 = self.ns.replicas[-1].energy
self.niter = 100
for i in xrange(self.niter):
self.ns.one_iteration()
self.Emax = self.ns.replicas[-1].energy
self.Emin = self.ns.replicas[0].energy
def test1(self):
print "running TestNS"
self.assert_(len(self.ns.replicas) == self.nreplicas)
self.assert_(self.Emax < self.Emax0)
self.assert_(self.Emin < self.Emax)
self.assert_(self.Emin >= 0)
self.assert_(self.ns.stepsize != self.stepsize)
self.assertEqual(len(self.ns.max_energies), self.niter * self.nproc)
class TestNS_LJ(unittest.TestCase):
def setUp(self):
self.setUp1()
def compute_cv(self, Tmin=.01, Tmax=3., nT=100):
T = np.arange(Tmin, Tmax, (Tmax - Tmin) / nT)
Cv = compute_cv_c(np.array(self.ns.max_energies),
float(self.nproc),
float(self.ndof),
T.min(),
T.max(),
T.size,
float(self.ndof),
live=False)
return T, Cv
def set_up_system(self):
self.natoms = 13
self.gmin = -44.3269
self.system = LJClusterSENS(self.natoms, 2.5)
self.ndof = 3 * self.natoms - 6
def setUp1(self, nproc=1):
self.set_up_system()
self.nreplicas = 10
self.stepsize = 0.01
self.nproc = nproc
self.mc_runner = self.system.get_mc_walker(mciter=100)
self.ns = NestedSampling(self.system,
self.nreplicas,
self.mc_runner,
stepsize=0.1,
nproc=nproc,
verbose=False)
self.Emax0 = self.ns.replicas[-1].energy
self.niter = 100
for i in xrange(self.niter):
self.ns.one_iteration()
self.Emax = self.ns.replicas[-1].energy
self.Emin = self.ns.replicas[0].energy
def test1(self):
self.assert_(len(self.ns.replicas) == self.nreplicas)
self.assert_(self.Emax < self.Emax0)
self.assert_(self.Emin < self.Emax)
self.assert_(self.Emin < 0)
self.assert_(self.Emin >= self.gmin)
self.assert_(self.ns.stepsize != self.stepsize)
self.assertEqual(len(self.ns.max_energies), self.niter * self.nproc)
self.assertEqual(self.ns.failed_mc_walks, 0)
def run_ns(self, max_iter=100, Etol=1e-4):
# max_iter = 10000
# self.Etol = .01
self.Etol = Etol
for i in xrange(int(max_iter)):
self.ns.one_iteration()
deltaE = self.ns.replicas[-1].energy - self.ns.replicas[0].energy
if deltaE < self.Etol:
break
self.niter = i + 1
self.Emax = self.ns.replicas[-1].energy
self.Emin = self.ns.replicas[0].energy
