def main(): parser = argparse.ArgumentParser(description="do nested sampling on a Lennard Jones cluster") parser.add_argument("natoms", type=int, help="number of atoms") parser.add_argument("-K", "--nreplicas", type=int, help="number of replicas", default=300) parser.add_argument("-n", "--mciter", type=int, default=1000, help="number of steps in the monte carlo walk") parser.add_argument("-P", "--nproc", type=int, help="number of processors", default=1) parser.add_argument("-q", action="store_true", help="turn off verbose printing of information at every step") parser.add_argument("--radius", type=float, default=2.5, help="maintain atoms in a sphere of this radius") parser.add_argument("--iprint", type=int, default=1, help="if verbose, status messages will be printed every iprint steps") parser.add_argument("--sens-exact", action="store_true", help="use the exact version of superposition enhanced nested sampling") parser.add_argument("--sens-approximate", action="store_true", help="use the approximate version of superposition enhanced nested sampling") parser.add_argument("--minprob", type=float, default=1., help="only for sens-approximate: probability of sampling from the database (by default <minprob>/K)," "default value 1") parser.add_argument("--energy-offset", type=float, default=2.5, help="only for sens-approximate: value of Emax where the probabilty" "starts to become non zero is <energy_max_database> + <energy_offset>") parser.add_argument("--db", type=str, help="location of the database", default="") parser.add_argument("--nminima", type=int, default=-1, help="number of minima from the database to use. If negative, use all minima") parser.add_argument("--energy-onset", type=float, help="energy at which start sampling from database, by default maximum energy in database",default=None) parser.add_argument("--stop-crit", type=float, default=1e-3, help="run will terminate when stop_crit is larger than the difference between the maximum and minimum replica energies") parser.add_argument("--cpfile", type=str, help="checkpoint file name, unless renamed it takes default output name: <label>.replicas.p", default = None) parser.add_argument("--cpfreq", type=int, help="checkpointing frequency in number of steps", default = 10000) parser.add_argument("--cpstart", action="store_true", help="start calculation from checkpoint binary file") 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) args = parser.parse_args() print args if (args.sens_exact or args.sens_approximate) and args.db == "": raise Exception("for sens you must specify a database file") system = LJClusterSENS(args.natoms, args.radius) energy_accuracy = 1e-3 if args.sens_exact or args.sens_approximate: database = system.create_database(args.db, createdb=False) if args.nminima <= 0 or args.nminima > database.number_of_minima(): minima = database.minima() else: minima = database.minima()[:args.nminima] print "using", len(minima), "minima" 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 mcrunner = system.get_mc_walker(args.mciter) nskwargs = dict(nproc=args.nproc, verbose=not args.q, iprint=args.iprint, dispatcher_URI = dispatcherURI, cpfreq = args.cpfreq, cpfile = args.cpfile, cpstart = args.cpstart) # create the potential object potential = system.get_potential() potential.get_energy = potential.getEnergy # create the replicas replicas = [] for i in xrange(args.nreplicas): x = system.get_random_configuration() e = potential.getEnergy(x) replicas.append(Replica(x, e)) print "mciter", args.mciter print "radius", args.radius if args.sens_exact: hsa_sampler = HSASamplerCluster(minima, system.k, copy_minima=True, center_minima=True, energy_accuracy=energy_accuracy, compare_structures=system.get_compare_exact(), mindist=system.get_mindist(), minimizer=system.get_minimizer(), debug=True) ns = NestedSamplingSAExact(replicas, mcrunner, hsa_sampler, potential, config_tests=system.get_config_tests(), **nskwargs) elif args.sens_approximate: ns = NestedSamplingSA(replicas, mcrunner, minima, system.k, config_tests=system.get_config_tests(), minprob=args.minprob, energy_offset=args.energy_offset, energy_onset = args.energy_onset, copy_minima=True, center_minima=True, **nskwargs) else: ns = NestedSampling(replicas, mcrunner, **nskwargs) run_nested_sampling(ns, label="lj"+str(args.natoms), etol=args.stop_crit, )
class TestSENSExact_LJ(unittest.TestCase): def setUp(self): self.seed = np.random.randint(1000000) # self.seed = 549670 # failed self.assertGreater(self.ns.count_sampled_minima, 0) print "seed", self.seed np.random.seed(self.seed) self.setUp1() def setUp1(self, nproc=1): self.natoms = 31 self.system = LJClusterSENS(self.natoms, 2.5) self.ndof = 3*self.natoms - 6 self.nreplicas = 10 self.stepsize = 0.01 self.nproc = nproc try: self.database = self.system.create_database("/scratch/scratch2/js850/sens/testruns/lj31/lj31.sqlite", createdb=False) except IOError: self.database = build_database(self.system, 4) self.minima = list(self.database.minima()) assert self.database.number_of_minima() > 1, "%d minima" % self.database.number_of_minima() self.sampler = HSASamplerCluster(self.minima, self.ndof, copy_minima=True, center_minima=True, compare_structures=self.system.get_compare_exact(), mindist=self.system.get_mindist(), minimizer=self.system.get_minimizer()) self.Emax = min((m.energy for m in self.minima)) + 1. # for performing transformations like rotations, translations, permutations, etc self.transform = TransformAtomicCluster() # this is a list of random transformations that don't change the energy self.transformations = [self.rtrans, self.rrot, self.invert, self.rperm] def rtrans(self, x): vec3 = np.random.uniform(-1,1,3) self.transform.translate(x, vec3) def rrot(self, x): q = rotations.random_q() mx = rotations.q2mx(q) self.transform.rotate(x, mx) def invert(self, x): self.transform.invert(x) def rperm(self, x): perm = range(self.natoms) np.random.shuffle(perm) self.transform.permute(x, perm) def do_test(self, tform): # sample a configurations fr # sample a configuration from the HSA m, xsampled = self.sampler.sample_coords(self.Emax) # get the energy of that configuration in the HSA E_HSA = self.sampler.compute_energy(xsampled, m) # get the real energy of the sampled configuration pot = self.system.get_potential() Esampled = pot.getEnergy(xsampled) r = Replica(xsampled, Esampled) # transform xsampled in a way that preserves the real energy but not necessarily the HSA energy tform(xsampled) # assert the real energy has not changed Etrans = pot.getEnergy(xsampled) self.assertAlmostEqual(r.energy, Etrans, delta=1e-4) # use the nested sampling routine to compute the HSA energy of xsampled. # This should undo the transformations we applied and find the correct HSA energy m_quench, E_HSA_computed = self.sampler.compute_energy_in_HSA(r.energy, r.x) # assert that self.ns._compute_energy_in_SA(r) was able to recover the correct HSA energy self.assertIsNotNone(E_HSA_computed) self.assertAlmostEqual(E_HSA, E_HSA_computed, delta=1e-4) self.assertAlmostEqual(m.energy, m_quench.energy, delta=1e-4) def fchain(self, flist): """return a function which applies all of the functions in flist to the input""" def function_chain(x): for f in reversed(flist): f(x) return function_chain def test1(self): """run do_test() on all combinations transformations""" for f in self.transformations: self.do_test(f) def test_2(self): """run do_test() on all combinations of length 2 of the transformations """ for flist in itertools.product(self.transformations, repeat=2): tform = self.fchain(flist) self.do_test(tform) def test_10(self): """run do_test() on all combinations of length 10 of the transformations """ maxiter = 500 i = 0 for flist in itertools.product(self.transformations, repeat=10): tform = self.fchain(flist) self.do_test(tform) i += 1 if i >= maxiter: break
class TestSENSExact_LJ(_test_ns_lj.TestNS_LJ): def setUp(self): self.seed = np.random.randint(1000000) # self.seed = 549670 # failed self.assertGreater(self.ns.count_sampled_minima, 0) print "seed", self.seed np.random.seed(self.seed) self.setUp1() def set_up_system(self): self.natoms = 6 self.gmin = -12.7121 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# * nproc self.stepsize = 0.01 self.nproc = nproc self.database = self.system.create_database() # add some minima to the database bh = self.system.get_basinhopping(self.database, outstream=None) while self.database.number_of_minima() < 2: bh.run(1) # compute the thermodynamic information get_thermodynamic_information(self.system, self.database) get_all_normalmodes(self.system, self.database) self.minima = list(self.database.minima()) assert self.database.number_of_minima() > 1, "%d minima" % self.database.number_of_minima() self.mc_runner = self.system.get_mc_walker(mciter=200) self.energy_accuracy = 1e-4 self.hsa_sampler = HSASamplerCluster(self.minima, self.system.k, copy_minima=True, center_minima=True, energy_accuracy=self.energy_accuracy, compare_structures=self.system.get_compare_exact(), mindist=self.system.get_mindist(), minimizer=self.system.get_minimizer(), debug=True) replicas = _utils.create_replicas(self.system, self.nreplicas) potential = self.system.get_potential() potential.get_energy = potential.getEnergy self.ns = NestedSamplingSAExact(replicas, self.mc_runner, self.hsa_sampler, potential, config_tests=self.system.get_config_tests(), nproc=nproc, verbose=True, iprint=1, debug=True) self.Emax0 = self.ns.replicas[-1].energy self.run_ns(max_iter=1000, Etol=.001) def test1(self): super(TestSENSExact_LJ, self).test1() self.assertGreater(self.ns.number_swaps_accepted(), 0)