class TestNS(unittest.TestCase):
def setUp(self):
self.setUp1()
def setUp1(self, nproc=1):
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)
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)
self.etol = 0.01
run_nested_sampling(self.ns, label="test", etol=self.etol)
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.ns.stepsize != self.stepsize)
self.assertGreater(len(self.ns.max_energies), 0)
self.assertLess(self.Emin, self.Emax)
self.assertLess(self.Emax - self.Emax, self.etol)
self.assertLess(self.Emax, 2. * self.etol)
class TestNS(unittest.TestCase):
def setUp(self):
self.setUp1()
def setUp1(self, nproc=1):
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)
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)
self.etol = 0.01
run_nested_sampling(self.ns, label="test", etol=self.etol)
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.ns.stepsize != self.stepsize)
self.assertGreater(len(self.ns.max_energies), 0)
self.assertLess(self.Emin, self.Emax)
self.assertLess(self.Emax - self.Emax, self.etol)
self.assertLess(self.Emax, 2. * self.etol)
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 prepare(self):
self.ndim = 6
self.harmonic = Harmonic(self.ndim)
self.x0 = np.zeros(self.ndim)
self.energy = self.harmonic.get_energy(self.x0)
self.mciter = 100
self.mcwalker = MonteCarloWalker(self.harmonic, mciter=self.mciter)
self.stepsize = 0.1
self.Emax = 10.
self.seed = None
def main():
parser = argparse.ArgumentParser(description="do nested sampling on a p[article in a n-dimensional Harmonic well")
parser.add_argument("-K", "--nreplicas", type=int, help="number of replicas", default=300)
parser.add_argument("-A", "--ndof", type=int, help="number of degrees of freedom", default=4)
parser.add_argument("-P", "--nproc", type=int, help="number of processors", default=1)
parser.add_argument("-N", "--nsteps", type=int, help="number of MC steps per NS iteration", default=100)
parser.add_argument("--stepsize", type=float, help="stepsize, adapted between NS iterations", default=0.1)
parser.add_argument("--etol", type=float, help="energy tolerance: the calculation terminates when the energy difference \
between Emax and Emin is less than etol", default=0.01)
parser.add_argument("-q", action="store_true", help="turn off verbose printing of information at every step")
parser.add_argument("--dispatcherURI", action="store_true", help="use URI of the dispatcher server in default location",default=False)
parser.add_argument("--dispatcherURI-file", type=str, help="use URI of the dispatcher server if different from default",default=None)
#set basic parameters
args = parser.parse_args()
ndof = args.ndof
nproc = args.nproc
nsteps = args.nsteps
nreplicas = args.nreplicas
stepsize = args.stepsize
etol = args.etol
#try to read dispatecher URI from default file location
if args.dispatcherURI is True:
with open ("dispatcher_uri.dat", "r") as rfile:
dispatcherURI = rfile.read().replace('\n', '')
elif args.dispatcherURI_file != None:
with open (args.dispatcherURI_file, "r") as rfile:
dispatcherURI = rfile.read().replace('\n', '')
else:
dispatcherURI = None
#construct potential (cost function)
potential = Harmonic(ndof)
#construct Monte Carlo walker
mc_runner = MonteCarloWalker(potential, mciter=nsteps)
#initialise replicas (initial uniformly samples set of configurations)
replicas = []
for _ in xrange(nreplicas):
x = potential.get_random_configuration()
replicas.append(Replica(x, potential.get_energy(x)))
#construct Nested Sampling object and pass dispatcher address
ns = NestedSampling(replicas, mc_runner, stepsize=stepsize, nproc=nproc, dispatcher_URI=dispatcherURI,
max_stepsize=10, verbose=not args.q)
#run Nested Sampling (NS), output:
## label.energies (one for each iteration)
## label.replicas_final (live replica energies when NS terminates)
run_nested_sampling(ns, label="run_hparticle", etol=etol)
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)
def prepare(self):
self.ndim = 6
self.harmonic = Harmonic(self.ndim)
self.x0 = np.zeros(self.ndim)
self.energy = self.harmonic.get_energy(self.x0)
self.mciter = 100
self.mcwalker = MonteCarloWalker(self.harmonic, mciter=self.mciter)
self.stepsize = 0.1
self.Emax = 10.0
self.seed = None
def setUp1(self, nproc=1):
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)
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)
self.etol = 0.01
run_nested_sampling(self.ns, label="test", etol=self.etol)
self.Emax = self.ns.replicas[-1].energy
self.Emin = self.ns.replicas[0].energy
class TestHarmonic(unittest.TestCase):
def setUp(self):
self.ndim = 3
self.harmonic = Harmonic(3)
def test_energy(self):
x = np.zeros(self.ndim)
e = self.harmonic.get_energy(x)
self.assertAlmostEqual(e, 0., 7)
def test_e2(self):
x = np.ones(self.ndim)
x *= 1. / np.linalg.norm(x)
e = self.harmonic.get_energy(x)
self.assertAlmostEqual(e, 0.5, 7)
def test_random_config(self):
r = 1.
x = self.harmonic.get_random_configuration(r)
xnorm = np.linalg.norm(x)
self.assertLessEqual(xnorm, r)
def main():
parser = argparse.ArgumentParser(
description="must pass the URI of the dispatcher")
parser.add_argument("ndim", type=int, help="number of dimensions")
parser.add_argument("dispatcher_URI", type=str, help="name for the worker")
parser.add_argument("-n",
"--mciter",
type=int,
default=1000,
help="number of steps in the monte carlo walk")
parser.add_argument("--radius",
type=float,
default=2.5,
help="maintain atoms in a sphere of this radius")
parser.add_argument("--worker-name",
type=str,
help="name for the worker",
default=None)
parser.add_argument(
"--host",
type=str,
help="address of the host (node on which the worker is started)",
default=None)
parser.add_argument("--port",
type=int,
help="port number on which the worker is started)",
default=0)
parser.add_argument("--server-type",
type=str,
help="multiplex or threaded",
default="multiplex")
args = parser.parse_args()
#===========================================================================
# MUST SET THE SYSTEM THEN GET THE RUNNER TO PASS
#===========================================================================
system = Harmonic(args.ndim)
mc_runner = MonteCarloWalker(system, mciter=args.mciter)
dispatcher_URI = args.dispatcher_URI
worker_name = args.worker_name
host = args.host
port = args.port
server_type = args.server_type
worker = pyro_worker(dispatcher_URI,
mc_runner,
worker_name=worker_name,
host=host,
port=port,
server_type=server_type)
worker._start_worker()
def main():
parser = argparse.ArgumentParser(description="do nested sampling on a p[article in a n-dimensional Harmonic well")
parser.add_argument("-K", "--nreplicas", type=float, help="number of replicas", default=1e1)
parser.add_argument("-A", "--ndof", type=int, help="number of degrees of freedom", default=3)
parser.add_argument("-P", "--nproc", type=int, help="number of processors", default=1)
parser.add_argument("-N", "--nsteps", type=int, help="number of MC steps per NS iteration", default=int(1e3))
parser.add_argument("--stepsize", type=float, help="stepsize, adapted between NS iterations", default=20)
parser.add_argument("--etol", type=float, help="energy tolerance: the calculation terminates when the energy difference \
between Emax and Emin is less than etol", default=0.1)
parser.add_argument("-q", action="store_true", help="turn off verbose printing of information at every step")
args = parser.parse_args()
ndof = args.ndof
nproc = args.nproc
nsteps = int(args.nsteps)-8
nreplicas = int(args.nreplicas)
stepsize = args.stepsize
etol = args.etol
#construct potential (cost function)
potential = Harmonic(ndof)
#construct Monte Carlo walker
mc_runner = MonteCarloWalker(potential, mciter=nsteps)
#initialise replicas (initial uniformly samples set of configurations)
replicas = []
for _ in range(nreplicas):
x = potential.get_random_configuration()
print(x)
print(potential.get_energy(x))
replicas.append(Replica(x, potential.get_energy(x)))
#construct Nested Sampling object
ns = NestedSampling(replicas, mc_runner, stepsize=stepsize, nproc=nproc, max_stepsize=10, verbose=not args.q)
#run Nested Sampling (NS), output:
## label.energies (one for each iteration)
## label.replicas_final (live replica energies when NS terminates)
run_nested_sampling(ns, label="run_hparticle", etol=etol)
def main():
parser = argparse.ArgumentParser(description="do nested sampling on a p[article in a n-dimensional Harmonic well")
parser.add_argument("-K", "--nreplicas", type=int, help="number of replicas", default=300)
parser.add_argument("-A", "--ndof", type=int, help="number of degrees of freedom", default=4)
parser.add_argument("-P", "--nproc", type=int, help="number of processors", default=1)
parser.add_argument("-N", "--nsteps", type=int, help="number of MC steps per NS iteration", default=100)
parser.add_argument("--stepsize", type=float, help="stepsize, adapted between NS iterations", default=0.1)
parser.add_argument("--etol", type=float, help="energy tolerance: the calculation terminates when the energy difference \
between Emax and Emin is less than etol", default=0.01)
parser.add_argument("-q", action="store_true", help="turn off verbose printing of information at every step")
args = parser.parse_args()
ndof = args.ndof
nproc = args.nproc
nsteps = args.nsteps
nreplicas = args.nreplicas
stepsize = args.stepsize
etol = args.etol
#construct potential (cost function)
potential = Harmonic(ndof)
#construct Monte Carlo walker
mc_runner = MonteCarloWalker(potential, mciter=nsteps)
#initialise replicas (initial uniformly samples set of configurations)
replicas = []
for _ in xrange(nreplicas):
x = potential.get_random_configuration()
replicas.append(Replica(x, potential.get_energy(x)))
#construct Nested Sampling object
ns = NestedSampling(replicas, mc_runner, stepsize=stepsize, nproc=nproc, max_stepsize=10, verbose=not args.q)
#run Nested Sampling (NS), output:
## label.energies (one for each iteration)
## label.replicas_final (live replica energies when NS terminates)
run_nested_sampling(ns, label="run_hparticle", etol=etol)
class TestMCWalker(unittest.TestCase):
def setUp(self):
self.prepare()
self.runwalker()
def prepare(self):
self.ndim = 6
self.harmonic = Harmonic(self.ndim)
self.x0 = np.zeros(self.ndim)
self.energy = self.harmonic.get_energy(self.x0)
self.mciter = 100
self.mcwalker = MonteCarloWalker(self.harmonic, mciter=self.mciter)
self.stepsize = 0.1
self.Emax = 10.
self.seed = None
def runwalker(self):
self.res = self.mcwalker(self.x0,
self.stepsize,
self.Emax,
self.energy,
seed=self.seed)
def test1(self):
self.assert_(np.all(self.x0 != self.res.x))
def test2(self):
self.assert_(self.energy != self.res.energy)
self.assert_(self.res.energy < self.Emax)
def test3(self):
self.assert_(self.res.naccept > 0)
def test4(self):
self.assert_(self.res.nsteps == self.mciter)
def test_large_stepsize(self):
self.stepsize = 1e4
self.runwalker()
self.assert_(self.res.naccept == 0)
self.assert_(self.energy == self.res.energy)
self.assert_(np.all(self.x0 == self.res.x))
def setUp1(self, nproc=1):
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)
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)
self.etol = 0.01
run_nested_sampling(self.ns, label="test", etol=self.etol)
self.Emax = self.ns.replicas[-1].energy
self.Emin = self.ns.replicas[0].energy
class TestMCWalker(unittest.TestCase):
def setUp(self):
self.prepare()
self.runwalker()
def prepare(self):
self.ndim = 6
self.harmonic = Harmonic(self.ndim)
self.x0 = np.zeros(self.ndim)
self.energy = self.harmonic.get_energy(self.x0)
self.mciter = 100
self.mcwalker = MonteCarloWalker(self.harmonic, mciter=self.mciter)
self.stepsize = 0.1
self.Emax = 10.0
self.seed = None
def runwalker(self):
self.res = self.mcwalker(self.x0, self.stepsize, self.Emax, self.energy, seed=self.seed)
def test1(self):
self.assert_(np.all(self.x0 != self.res.x))
def test2(self):
self.assert_(self.energy != self.res.energy)
self.assert_(self.res.energy < self.Emax)
def test3(self):
self.assert_(self.res.naccept > 0)
def test4(self):
self.assert_(self.res.nsteps == self.mciter)
def test_large_stepsize(self):
self.stepsize = 1e4
self.runwalker()
self.assert_(self.res.naccept == 0)
self.assert_(self.energy == self.res.energy)
self.assert_(np.all(self.x0 == self.res.x))
def main():
parser = argparse.ArgumentParser(
description=
"do nested sampling on a p[article in a n-dimensional Harmonic well")
parser.add_argument("-K",
"--nreplicas",
type=int,
help="number of replicas",
default=300)
parser.add_argument("-A",
"--ndof",
type=int,
help="number of degrees of freedom",
default=4)
parser.add_argument("-P",
"--nproc",
type=int,
help="number of processors",
default=1)
parser.add_argument("-N",
"--nsteps",
type=int,
help="number of MC steps per NS iteration",
default=100)
parser.add_argument("--stepsize",
type=float,
help="stepsize, adapted between NS iterations",
default=0.1)
parser.add_argument(
"--etol",
type=float,
help=
"energy tolerance: the calculation terminates when the energy difference \
between Emax and Emin is less than etol",
default=0.01)
parser.add_argument(
"-q",
action="store_true",
help="turn off verbose printing of information at every step")
parser.add_argument(
"--dispatcherURI",
action="store_true",
help="use URI of the dispatcher server in default location",
default=False)
parser.add_argument(
"--dispatcherURI-file",
type=str,
help="use URI of the dispatcher server if different from default",
default=None)
#set basic parameters
args = parser.parse_args()
ndof = args.ndof
nproc = args.nproc
nsteps = args.nsteps
nreplicas = args.nreplicas
stepsize = args.stepsize
etol = args.etol
#try to read dispatecher URI from default file location
if args.dispatcherURI is True:
with open("dispatcher_uri.dat", "r") as rfile:
dispatcherURI = rfile.read().replace('\n', '')
elif args.dispatcherURI_file != None:
with open(args.dispatcherURI_file, "r") as rfile:
dispatcherURI = rfile.read().replace('\n', '')
else:
dispatcherURI = None
#construct potential (cost function)
potential = Harmonic(ndof)
#construct Monte Carlo walker
mc_runner = MonteCarloWalker(potential, mciter=nsteps)
#initialise replicas (initial uniformly samples set of configurations)
replicas = []
for _ in xrange(nreplicas):
x = potential.get_random_configuration()
replicas.append(Replica(x, potential.get_energy(x)))
#construct Nested Sampling object and pass dispatcher address
ns = NestedSampling(replicas,
mc_runner,
stepsize=stepsize,
nproc=nproc,
dispatcher_URI=dispatcherURI,
max_stepsize=10,
verbose=not args.q)
#run Nested Sampling (NS), output:
## label.energies (one for each iteration)
## label.replicas_final (live replica energies when NS terminates)
run_nested_sampling(ns, label="run_hparticle", etol=etol)
def setUp(self):
self.ndim = 3
self.harmonic = Harmonic(3)
