def __init__(self,
filename,
trigger,
filter=All(),
mode='ab',
truncate=False,
dynamic=None,
log=None):
super().__init__(trigger)
dynamic_validation = OnlyFrom(
['attribute', 'property', 'momentum', 'topology'],
preprocess=array_to_strings)
dynamic = ['property'] if dynamic is None else dynamic
self._param_dict.update(
ParameterDict(filename=str(filename),
filter=ParticleFilter,
mode=str(mode),
truncate=bool(truncate),
dynamic=[dynamic_validation],
_defaults=dict(filter=filter, dynamic=dynamic)))
self._log = None if log is None else _GSDLogWriter(log)
def __init__(self, nlist, default_r_cut=None, mode="none"):
self._nlist = OnlyTypes(md.nlist.NList, strict=True)(nlist)
tp_r_cut = TypeParameter('r_cut', 'particle_types',
TypeParameterDict(positive_real, len_keys=2))
if default_r_cut is not None:
tp_r_cut.default = default_r_cut
self._param_dict.update(ParameterDict(mode=OnlyFrom(['none', 'shift'])))
self.mode = mode
self._add_typeparam(tp_r_cut)
def __init__(self,
moves,
target,
solver,
types=None,
max_translation_move=None,
max_rotation_move=None):
super().__init__(target, solver)
# A flag for knowing when to update the maximum move sizes
self._should_update_move_sizes = False
# set up maximum trial move sizes
t_moves = TypeParameter(
'max_translation_move', 'particle_type',
TypeParameterDict(OnlyTypes(
float,
postprocess=self._flag_move_size_update,
allow_none=True),
len_keys=1))
r_moves = TypeParameter(
'max_rotation_move', 'particle_type',
TypeParameterDict(OnlyTypes(
float,
postprocess=self._flag_move_size_update,
allow_none=True),
len_keys=1))
self._typeparam_dict = {
'max_translation_move': t_moves,
'max_rotation_move': r_moves
}
# This is a bit complicated because we are having to ensure that we keep
# the list of tunables and the solver updated with the changes to
# attributes. However, these are simply forwarding a change along.
param_dict = ParameterDict(
moves=OnlyIf(to_type_converter([OnlyFrom(['a', 'd'])]),
postprocess=self._update_moves),
types=OnlyIf(to_type_converter([str]),
postprocess=self._update_types,
allow_none=True),
)
self._param_dict.update(param_dict)
self.target = target
self.solver = solver
self.moves = moves
self.types = types
self.max_rotation_move.default = max_rotation_move
self.max_translation_move.default = max_translation_move
if types is not None:
self._update_tunables(new_moves=moves, new_types=types)
def __init__(self, dt, aniso='auto', forces=None, constraints=None,
methods=None):
super().__init__(forces, constraints, methods)
self._param_dict = ParameterDict(
dt=float(dt),
aniso=OnlyFrom(['true', 'false', 'auto'],
preprocess=_preprocess_aniso),
_defaults=dict(aniso="auto")
)
if aniso is not None:
self.aniso = aniso
def __init__(self, buffer, exclusions, rebuild_check_delay, diameter_shift,
check_dist, max_diameter):
validate_exclusions = OnlyFrom([
'bond', 'angle', 'constraint', 'dihedral', 'special_pair', 'body',
'1-3', '1-4'
])
# default exclusions
params = ParameterDict(exclusions=[validate_exclusions],
buffer=float(buffer),
rebuild_check_delay=int(rebuild_check_delay),
check_dist=bool(check_dist),
diameter_shift=bool(diameter_shift),
max_diameter=float(max_diameter),
_defaults={'exclusions': exclusions})
self._param_dict.update(params)
def __init__(self, buffer, exclusions, rebuild_check_delay, check_dist,
mesh):
validate_exclusions = OnlyFrom([
'bond', 'angle', 'constraint', 'dihedral', 'special_pair', 'body',
'1-3', '1-4', 'meshbond'
])
validate_mesh = OnlyTypes(Mesh, allow_none=True)
# default exclusions
params = ParameterDict(exclusions=[validate_exclusions],
buffer=float(buffer),
rebuild_check_delay=int(rebuild_check_delay),
check_dist=bool(check_dist))
params["exclusions"] = exclusions
self._param_dict.update(params)
self._mesh = validate_mesh(mesh)
def __init__(
self,
boxmc,
moves,
target,
solver,
max_move_size=None,
):
super().__init__(target, solver)
# Flags for knowing when to update classes attributes
self._update_move_sizes = False
self._should_update_tunables = False
# This is a bit complicated because we are having to ensure that we keep
# the list of tunables and the solver updated with the changes to
# attributes. However, these are simply forwarding a change along.
params = ParameterDict(
boxmc=hoomd.hpmc.update.BoxMC,
moves=[
OnlyFrom(_MoveSizeTuneDefinition.acceptable_attrs,
postprocess=self._flag_new_tunables)
],
max_move_size=OnlyIf(
to_type_converter({
attr: OnlyTypes(float,
allow_none=True,
postprocess=self._flag_move_size_update)
for attr in _MoveSizeTuneDefinition.acceptable_attrs
}),))
params["boxmc"] = boxmc
params["moves"] = moves
if max_move_size is None:
max_move_size = {
attr: None for attr in _MoveSizeTuneDefinition.acceptable_attrs
}
params["max_move_size"] = max_move_size
self._param_dict.update(params)
self._update_tunables()
def __init__(self,
moves,
target,
solver,
types=None,
max_translation_move=None,
max_rotation_move=None):
def target_postprocess(target):
def check_fraction(value):
if 0 <= value <= 1:
return value
raise ValueError(
"Value {} should be between 0 and 1.".format(value))
self._update_tunables_attr('target', check_fraction(target))
self._tuned = 0
return target
def update_moves(value):
self._update_tunables(new_moves=value)
self._tuned = 0
return value
def update_types(value):
self._update_tunables(new_types=value)
self._tuned = 0
return value
# A flag for knowing when to update the maximum move sizes
self._update_move_sizes = False
self._tunables = []
# A counter when tuned reaches 1 it means that the tuner has reported
# being tuned one time in a row. However, as the first run of the tuner
# is likely at timestep 0 which means that the counters are (0, 0) and
# _MoveSizeTuneDefinition returns y == target for that case, we need two
# rounds of tuning to be sure that we have converged. Since, in general,
# solvers do not do much if any work on already tuned tunables, this is
# not a performance problem.
self._tuned = 0
self._is_attached = False
# set up maximum trial move sizes
def flag_move_size_update(value):
self._update_move_sizes = True
return value
t_moves = TypeParameter(
'max_translation_move', 'particle_type',
TypeParameterDict(OnlyTypes(float,
postprocess=flag_move_size_update,
allow_none=True),
len_keys=1))
r_moves = TypeParameter(
'max_rotation_move', 'particle_type',
TypeParameterDict(OnlyTypes(float,
postprocess=flag_move_size_update,
allow_none=True),
len_keys=1))
self._typeparam_dict = {
'max_translation_move': t_moves,
'max_rotation_move': r_moves
}
# This is a bit complicated because we are having to ensure that we keep
# the list of tunables and the solver updated with the changes to
# attributes. However, these are simply forwarding a change along.
param_dict = ParameterDict(
moves=OnlyIf(to_type_converter([OnlyFrom(['a', 'd'])]),
postprocess=update_moves),
types=OnlyIf(to_type_converter([str]),
postprocess=update_types,
allow_none=True),
target=OnlyTypes(float, postprocess=target_postprocess),
solver=SolverStep)
self._param_dict.update(param_dict)
self.target = target
self.solver = solver
self.moves = moves
self.types = types
self.max_rotation_move.default = max_rotation_move
self.max_translation_move.default = max_translation_move
if types is not None:
self._update_tunables(new_moves=moves, new_types=types)