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)
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="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 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)
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 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))
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") 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)
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)