def scale_solver(cls, trigger, target, max_chain_time=None, max_scale=2., gamma=1., tol=1e-2): """Create a `ChainTime` tuner with a `hoomd.tune.ScaleSolver`. Args: trigger (hoomd.trigger.Trigger): ``Trigger`` to determine when to run the tuner. target (float): The number of collisions in a chain that is desired. max_chain_time (float): The maximum value of chain time to attempt. max_scale (float): The maximum amount to scale the current chain_time value with. gamma (float): The value of gamma to pass through to `hoomd.tune.ScaleSolver`. Controls the size of corrections to the move size (larger values increase stability while increasing convergence time). tol (float): The absolute tolerance to allow between the current acceptance rate and the target before the move sizes are considered tuned. The tolerance should not be too much lower than the default of 0.01 as acceptance rates can vary significantly at typical tuning rates. """ solver = ScaleSolver(max_scale, gamma, 'positive', tol) return cls(trigger, target, solver, max_chain_time)
def scale_solver(cls, trigger, moves, target, types=None, max_translation_move=None, max_rotation_move=None, max_scale=2., gamma=1., tol=1e-2): """Create a `MoveSize` tuner with a `hoomd.tune.ScaleSolver`. Args: trigger (hoomd.trigger.Trigger): ``Trigger`` to determine when to run the tuner. moves (list[str]): A list of types of moves to tune. Available options are 'a' and 'd'. target (float): The acceptance rate for trial moves that is desired. The value should be between 0 and 1. types (list[str]): A list of string particle types to tune the move size for, defaults to None which upon attaching will tune all types in the system currently. max_translation_move (float): The maximum value of a translational move size to attempt. max_rotation_move (float): The maximum value of a rotational move size to attempt. gamma (float): The value of gamma to pass through to `hoomd.tune.ScaleSolver`. Controls the size of corrections to the move size (larger values increase stability while increasing convergence time). tol (float): The absolute tolerance to allow between the current acceptance rate and the target before the move sizes are considered tuned. The tolerance should not be too much lower than the default of 0.01 as acceptance rates can vary significantly at typical tuning rates. """ solver = ScaleSolver(max_scale, gamma, 'negative', tol) return cls(trigger, moves, target, solver, types, max_translation_move, max_rotation_move)
def scale_solver(cls, trigger, boxmc, moves, target, max_move_size=None, max_scale=2., gamma=1., tol=1e-2): """Create a `BoxMCMoveSize` tuner with a `hoomd.tune.ScaleSolver`. Args: trigger (hoomd.trigger.Trigger): ``Trigger`` to determine when to run the tuner. boxmc (hoomd.hpmc.update.BoxMC): The `hoomd.hpmc.update.BoxMC` object to tune. moves (list[str]): A list of types of moves to tune. Available options are 'a' and 'd'. target (float): The acceptance rate for trial moves that is desired. The value should be between 0 and 1. max_move_size (float): The maximum value of a volume move size to attempt. max_scale (float): Maximum scale factor. gamma (float): The value of gamma to pass through to `hoomd.tune.ScaleSolver`. Controls the size of corrections to the move size (larger values increase stability while increasing convergence time). tol (float): The absolute tolerance to allow between the current acceptance rate and the target before the move sizes are considered tuned. The tolerance should not be too much lower than the default of 0.01 as acceptance rates can vary significantly at typical tuning rates. """ solver = ScaleSolver(max_scale, gamma, 'negative', tol) return cls(trigger, boxmc, moves, target, solver, max_move_size)
(None, [(1000, True), (-1000, True)])] for domain, check_pairs in domain_check_pairs: attr_definition.domain = domain for x, in_domain in check_pairs: assert in_domain == attr_definition.in_domain(x) def test_hash(self, attr_definition, alternate_definition): assert hash(attr_definition) == hash(attr_definition) assert hash(attr_definition) != hash(alternate_definition) def test_eq(self, attr_definition, alternate_definition): assert attr_definition == attr_definition assert attr_definition != alternate_definition @pytest.fixture(params=[ScaleSolver(), SecantSolver()], ids=lambda solver: solver.__class__.__name__) def solver(request): return request.param @pytest.fixture def equation_definition(): """x^2 - 1, x = (1, -1)""" equation = dict(x=4) equation['y'] = lambda: equation['x']**2 return ManualTuneDefinition(get_x=lambda: equation['x'], set_x=lambda x: equation.__setitem__('x', x), get_y=lambda: equation['y'](), target=1)