Esempio n. 1
0
    def __init__(self,
                 system,
                 nreplicas,
                 mc_runner,
                 minima,
                 energy_accuracy,
                 compare_structures=None,
                 mindist=None,
                 copy_minima=True,
                 config_tests=None,
                 minimizer=None,
                 debug=True,
                 **kwargs):
        super(NestedSamplingSAExact, self).__init__(system, nreplicas,
                                                    mc_runner, **kwargs)
        self.debug = debug
        if copy_minima:
            self.minima = [_UnboundMinimum(m) for m in minima]
        else:
            self.minima = minima
        if self.verbose:
            self._check_minima()

        self.compare_structures = compare_structures
        if compare_structures is None:
            try:
                self.compare_structures = self.system.get_compare_exact()
            except NotImplementedError or AttributeError:
                pass

        self.mindist = mindist
        if mindist is None:
            try:
                self.mindist = self.system.get_mindist()
            except NotImplementedError or AttributeError:
                pass

        self.config_tests = config_tests
        if config_tests is None:
            try:
                self.config_tests = self.system.get_config_tests()
            except NotImplementedError or AttributeError:
                pass

        self.minimizer = minimizer
        if self.minimizer is None:
            self.minimizer = self.system.get_minimizer()

        self.minima_searcher = _MinimaSearcher(self.minima, energy_accuracy,
                                               self.compare_structures)
        self.sa_sampler = SASampler(self.minima, self.system.k)

        self.count_sampled_minima = 0
Esempio n. 2
0
    def setUp(self):
        self.natoms = 6
        self.system = LJCluster(self.natoms)

        # create a database
        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)

        get_thermodynamic_information(self.system, self.database)
        get_all_normalmodes(self.system, self.database)

        self.ndof = self.natoms * 3 - 6
        self.sampler = SASampler(self.database.minima(), self.ndof)
Esempio n. 3
0
    def __init__(self,
                 system,
                 nreplicas,
                 mc_runner,
                 minima,
                 minprob=None,
                 energy_offset=None,
                 **kwargs):
        super(NestedSamplingSA, self).__init__(system, nreplicas, mc_runner,
                                               **kwargs)
        self.minima = minima
        self.bh_sampler = SASampler(self.minima, self.system.k)
        if minprob is None:
            raise ValueError("minprob cannot be None")
        self.minprob = minprob
        if energy_offset is None:
            self.energy_offset = 2.5
        else:
            self.energy_offset = energy_offset

        self.count_sampled_minima = 0