def __init__(self, test_particle_type, num_samples):
# store metadata
param_dict = ParameterDict(test_particle_type=str, num_samples=int)
param_dict.update(
dict(test_particle_type=test_particle_type,
num_samples=num_samples))
self._param_dict.update(param_dict)
def __init__(self, filter, kT, tau, S, tauS, couple, box_dof=[True,True,True,False,False,False], rescale_all=False, gamma=0.0):
# store metadata
param_dict = ParameterDict(
filter=ParticleFilter,
kT=Variant,
tau=float(tau),
S=OnlyIf(to_type_converter((Variant,)*6), preprocess=self._preprocess_stress),
tauS=float(tauS),
couple=str(couple),
box_dof=[bool,]*6,
rescale_all=bool(rescale_all),
gamma=float(gamma),
translational_thermostat_dof=(float, float),
rotational_thermostat_dof=(float, float),
barostat_dof=(float, float, float, float, float, float)
)
param_dict.update(
dict(filter=filter,
kT=kT,
S=S,
couple=couple,
box_dof=box_dof,
translational_thermostat_dof=(0, 0),
rotational_thermostat_dof=(0, 0),
barostat_dof=(0, 0, 0, 0, 0, 0)))
# set defaults
self._param_dict.update(param_dict)
def __init__(self, filter, rotation_diff=0.1):
# store metadata
param_dict = ParameterDict(
filter=ParticleFilter,
rotation_diff=float(rotation_diff),
constraint=OnlyTypes(
ConstraintForce, allow_none=True, preprocess=ellip_preprocessing
),
)
param_dict.update(
dict(
constraint=None,
rotation_diff=rotation_diff,
filter=filter,
)
)
# set defaults
self._param_dict.update(param_dict)
active_force = TypeParameter(
"active_force",
type_kind="particle_types",
param_dict=TypeParameterDict((1.0, 0.0, 0.0), len_keys=1),
)
active_torque = TypeParameter(
"active_torque",
type_kind="particle_types",
param_dict=TypeParameterDict((0.0, 0.0, 0.0), len_keys=1),
)
self._extend_typeparam([active_force, active_torque])
def __init__(self,
filter,
manifold_constraint,
tolerance=0.000001,
alpha=None):
# store metadata
param_dict = ParameterDict(
filter=ParticleFilter,
alpha=OnlyTypes(float, allow_none=True),
)
param_dict.update(dict(alpha=alpha, filter=filter))
# set defaults
self._param_dict.update(param_dict)
gamma = TypeParameter('gamma',
type_kind='particle_types',
param_dict=TypeParameterDict(1., len_keys=1))
gamma_r = TypeParameter('gamma_r',
type_kind='particle_types',
param_dict=TypeParameterDict((1., 1., 1.),
len_keys=1))
self._extend_typeparam([gamma, gamma_r])
super().__init__(manifold_constraint, tolerance)
def __init__(self,
filter,
flow_target,
slab_direction,
flow_direction,
n_slabs,
max_slab=-1,
min_slab=-1):
params = ParameterDict(
filter=hoomd.filter.ParticleFilter,
flow_target=hoomd.variant.Variant,
slab_direction=OnlyTypes(str,
strict=True,
postprocess=self._to_lowercase),
flow_direction=OnlyTypes(str,
strict=True,
postprocess=self._to_lowercase),
n_slabs=OnlyTypes(int, preprocess=self._preprocess_n_slabs),
max_slab=OnlyTypes(int, preprocess=self._preprocess_max_slab),
min_slab=OnlyTypes(int, preprocess=self._preprocess_min_slab),
flow_epsilon=float(1e-2))
params.update(
dict(filter=filter,
flow_target=flow_target,
slab_direction=slab_direction,
flow_direction=flow_direction,
n_slabs=n_slabs))
self._param_dict.update(params)
self._param_dict.update(dict(max_slab=max_slab))
self._param_dict.update(dict(min_slab=min_slab))
# This updater has to be applied every timestep
super().__init__(hoomd.trigger.Periodic(1))
def __init__(self,
filter,
S,
tauS,
couple,
box_dof=(True, True, True, False, False, False),
rescale_all=False,
gamma=0.0):
# store metadata
param_dict = ParameterDict(filter=ParticleFilter,
kT=Variant,
S=OnlyIf(
to_type_converter((Variant, ) * 6),
preprocess=self._preprocess_stress),
tauS=float,
couple=str,
box_dof=(bool, ) * 6,
rescale_all=bool,
gamma=float,
barostat_dof=(float, ) * 6)
param_dict.update(
dict(filter=filter,
kT=hoomd.variant.Constant(1.0),
S=S,
tauS=float(tauS),
couple=str(couple),
box_dof=tuple(box_dof),
rescale_all=bool(rescale_all),
gamma=float(gamma),
barostat_dof=(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)))
# set defaults
self._param_dict.update(param_dict)
def __init__(self,
filter,
kT,
seed,
alpha=None,
tally_reservoir_energy=False):
# store metadata
param_dict = ParameterDict(
filter=ParticleFilter,
kT=Variant,
seed=int(seed),
alpha=OnlyType(float, allow_none=True),
tally_reservoir_energy=bool(tally_reservoir_energy),
)
param_dict.update(dict(kT=kT, alpha=alpha, filter=filter))
# set defaults
self._param_dict.update(param_dict)
gamma = TypeParameter('gamma',
type_kind='particle_types',
param_dict=TypeParameterDict(1., len_keys=1))
gamma_r = TypeParameter('gamma_r',
type_kind='particle_types',
param_dict=TypeParameterDict((1., 1., 1.),
len_keys=1))
self._extend_typeparam([gamma, gamma_r])
def __init__(self, filter, seed, rotation_diff=0.1):
# store metadata
param_dict = ParameterDict(
filter=ParticleFilter,
seed=int(seed),
rotation_diff=float(rotation_diff),
constraint=OnlyType(ConstraintForce,
allow_none=True,
preprocess=ellip_preprocessing),
)
param_dict.update(
dict(constraint=None,
rotation_diff=rotation_diff,
seed=seed,
filter=filter))
# set defaults
self._param_dict.update(param_dict)
active_force = TypeParameter('active_force',
type_kind='particle_types',
param_dict=TypeParameterDict((1, 0, 0),
len_keys=1))
active_torque = TypeParameter('active_torque',
type_kind='particle_types',
param_dict=TypeParameterDict((0, 0, 0),
len_keys=1))
self._extend_typeparam([active_force, active_torque])
def __init__(self, filter):
# store metadata
param_dict = ParameterDict(filter=ParticleFilter, )
param_dict.update(dict(filter=filter, zero_force=False))
# set defaults
self._param_dict.update(param_dict)
def __init__(self, alchemical_kT, alchemical_dof, period=1):
# store metadata
param_dict = ParameterDict(alchemical_kT=Variant, period=int)
param_dict.update(dict(alchemical_kT=alchemical_kT, period=period))
# set defaults
self._param_dict.update(param_dict)
super().__init__(alchemical_dof)
def __init__(self, filter, kT, tau):
# store metadata
param_dict = ParameterDict(filter=ParticleFilter,
kT=Variant,
tau=float(tau))
param_dict.update(dict(filter=filter, kT=kT))
# set defaults
self._param_dict.update(param_dict)
def __init__(self, filter, limit=None):
# store metadata
param_dict = ParameterDict(
filter=ParticleFilter,
limit=OnlyType(float, allow_none=True),
zero_force=OnlyType(bool, allow_none=False),
)
param_dict.update(dict(filter=filter, limit=limit, zero_force=False))
# set defaults
self._param_dict.update(param_dict)
def __init__(self, filter, manifold_constraint, tolerance=0.000001):
# store metadata
param_dict = ParameterDict(
filter=ParticleFilter,
zero_force=OnlyTypes(bool, allow_none=False),
)
param_dict.update(dict(filter=filter, zero_force=False))
# set defaults
self._param_dict.update(param_dict)
super().__init__(manifold_constraint, tolerance)
def __init__(self, filter, kT, tau):
# store metadata
param_dict = ParameterDict(filter=ParticleFilter,
kT=Variant,
tau=float(tau),
translational_thermostat_dof=(float, float),
rotational_thermostat_dof=(float, float))
param_dict.update(
dict(kT=kT,
filter=filter,
translational_thermostat_dof=(0, 0),
rotational_thermostat_dof=(0, 0)))
# set defaults
self._param_dict.update(param_dict)
def __init__(self,
transfer_types,
ngibbs=1,
max_volume_rescale=0.1,
volume_move_probability=0.5,
trigger=1):
super().__init__(trigger)
self.ngibbs = int(ngibbs)
_default_dict = dict(ntrial=1)
param_dict = ParameterDict(
transfer_types=list(transfer_types),
max_volume_rescale=float(max_volume_rescale),
volume_move_probability=float(volume_move_probability),
**_default_dict)
self._param_dict.update(param_dict)
typeparam_fugacity = TypeParameter(
'fugacity',
type_kind='particle_types',
param_dict=TypeParameterDict(
hoomd.variant.Variant,
len_keys=1,
_defaults=hoomd.variant.Constant(0.0)))
self._extend_typeparam([typeparam_fugacity])
def __init__(self, target, solver, max_chain_time=None):
# A flag for knowing when to update the maximum move sizes
self._update_chain_time = False
# 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
# _ChainTimeTuneDefinition 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
self._chain_time_def = _ChainTimeTuneDefinition(
target, (self._min_chain_time, max_chain_time))
param_dict = ParameterDict(
target=OnlyTypes(float,
postprocess=self._process_chain_time_target),
solver=SolverStep,
max_chain_time=OnlyTypes(
float,
allow_none=True,
postprocess=self._process_chain_time_range),
min_chain_time=OnlyTypes(
float, postprocess=self._process_chain_time_range))
self._param_dict.update(param_dict)
self.target = target
self.solver = solver
self.max_chain_time = max_chain_time
self.min_chain_time = self._min_chain_time
def __init__(self, reference_positions, trigger=1):
super().__init__(trigger)
self._param_dict.update(
ParameterDict({
"reference_positions": NDArrayValidator(np.float64, (None, 3))
}))
self.reference_positions = reference_positions
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, filter, manifold_constraint):
# store metadata
super().__init__(filter)
param_dict = ParameterDict(
manifold_constraint=OnlyTypes(Manifold, allow_none=False))
param_dict["manifold_constraint"] = manifold_constraint
self._param_dict.update(param_dict)
def __getstate__(self):
state = copy.copy(self.__dict__)
state.pop('_comm', None)
# This is to handle when the output specified is just stdout. By default
# file objects like this are not picklable, so we need to handle it
# differently. We let `None` represent stdout in the state dictionary.
# Most other file like objects will simply fail to be pickled here.
if self.output == stdout:
param_dict = ParameterDict()
param_dict.update(state['_param_dict'])
state['_param_dict'] = param_dict
del state['_param_dict']['output']
state['_param_dict']['output'] = None
return state
else:
return super().__getstate__()
def __init__(self, r_cut_constituent, code_constituent, r_cut_isotropic,
code_isotropic, param_array_constituent,
param_array_isotropic):
param_dict = ParameterDict(
r_cut_constituent=float(r_cut_constituent),
r_cut_isotropic=float(r_cut_isotropic),
leaf_capacity=int(4),
param_array_constituent=NDArrayValidator(dtype=np.float32,
shape=(None, )),
param_array_isotropic=NDArrayValidator(dtype=np.float32,
shape=(None, )),
code_constituent=str,
code_isotropic=str,
)
param_dict['param_array_constituent'] = param_array_constituent
param_dict['param_array_isotropic'] = param_array_isotropic
self._param_dict.update(param_dict)
# add union specific per-type parameters
typeparam_positions = TypeParameter(
'positions',
type_kind='particle_types',
param_dict=TypeParameterDict([(float, float, float)], len_keys=1),
)
typeparam_orientations = TypeParameter(
'orientations',
type_kind='particle_types',
param_dict=TypeParameterDict([(float, float, float, float)],
len_keys=1),
)
typeparam_diameters = TypeParameter(
'diameters',
type_kind='particle_types',
param_dict=TypeParameterDict([float], len_keys=1),
)
typeparam_charges = TypeParameter(
'charges',
type_kind='particle_types',
param_dict=TypeParameterDict([float], len_keys=1),
)
typeparam_typeids = TypeParameter(
'typeids',
type_kind='particle_types',
param_dict=TypeParameterDict([int], len_keys=1),
)
self._extend_typeparam([
typeparam_positions, typeparam_orientations, typeparam_diameters,
typeparam_charges, typeparam_typeids
])
self.code_constituent = code_constituent
self.code_isotropic = code_isotropic
def __init__(self,
logger,
output=stdout,
header_sep='.',
delimiter=' ',
pretty=True,
max_precision=10,
max_header_len=None):
def writable(fh):
if not fh.writable():
raise ValueError("file-like object must be writable.")
return fh
param_dict = ParameterDict(header_sep=str,
delimiter=str,
min_column_width=int,
max_header_len=OnlyTypes(int,
allow_none=True),
pretty=bool,
max_precision=int,
output=OnlyTypes(_OutputWriter,
postprocess=writable),
logger=Logger)
param_dict.update(
dict(header_sep=header_sep,
delimiter=delimiter,
min_column_width=max(10, max_precision + 6),
max_header_len=max_header_len,
max_precision=max_precision,
pretty=pretty,
output=output,
logger=logger))
self._param_dict = param_dict
# internal variables that are not part of the state.
# Ensure that only scalar and potentially string are set for the logger
if (LoggerCategories.scalar not in logger.categories
or logger.categories & self._invalid_logger_categories !=
LoggerCategories.NONE):
raise ValueError(
"Given Logger must have the scalar categories set.")
self._cur_headers_with_width = dict()
self._fmt = _Formatter(pretty, max_precision)
self._comm = None
def __init__(self, manifold_constraint, tolerance):
param_dict = ParameterDict(manifold_constraint=OnlyTypes(
Manifold, allow_none=False),
tolerance=float(tolerance))
param_dict['manifold_constraint'] = manifold_constraint
# set defaults
self._param_dict.update(param_dict)
def __init__(self, trigger, active_force, rotational_diffusion):
super().__init__(trigger)
param_dict = ParameterDict(rotational_diffusion=hoomd.variant.Variant,
active_force=hoomd.md.force.Active)
param_dict["rotational_diffusion"] = rotational_diffusion
param_dict["active_force"] = active_force
self._add_dependency(active_force)
self._param_dict.update(param_dict)
def __init__(self, pivot_move_ratio=0.5, flip_probability=0.5, trigger=1):
super().__init__(trigger)
param_dict = ParameterDict(pivot_move_ratio=float(pivot_move_ratio),
flip_probability=float(flip_probability))
self._param_dict.update(param_dict)
self.instance = 0
def __init__(self, origin, normal, open=True):
param_dict = ParameterDict(origin=(float, float, float),
normal=(float, float, float),
open=bool)
param_dict["origin"] = origin
param_dict["normal"] = normal
param_dict["open"] = open
self._param_dict = param_dict
def __init__(self, buffer=0.4, exclusions=('bond',), rebuild_check_delay=1,
diameter_shift=False, check_dist=True, max_diameter=1.0,
deterministic=False):
super().__init__(buffer, exclusions, rebuild_check_delay,
diameter_shift, check_dist, max_diameter)
self._param_dict.update(
ParameterDict(deterministic=bool(deterministic)))
def __init__(self, trigger=200, grid=None):
self._param_dict = ParameterDict(
trigger=Trigger,
grid=OnlyTypes(int,
postprocess=ParticleSorter._to_power_of_two,
preprocess=ParticleSorter._natural_number,
allow_none=True))
self.trigger = trigger
self.grid = grid
def __init__(self, r_cut, code, param_array):
param_dict = ParameterDict(r_cut=float,
param_array=NDArrayValidator(
dtype=np.float32, shape=(None, )),
code=str)
param_dict['r_cut'] = r_cut
param_dict['param_array'] = param_array
self._param_dict.update(param_dict)
self.code = code
def __init__(self, trigger=200, grid=None):
super().__init__(trigger)
sorter_params = ParameterDict(
grid=OnlyTypes(int,
postprocess=ParticleSorter._to_power_of_two,
preprocess=ParticleSorter._natural_number,
allow_none=True))
self._param_dict.update(sorter_params)
self.grid = grid
