def __init__(self):
super().__init__()
# setup the coefficient options
params = TypeParameter(
"params", "special_pair_types",
TypeParameterDict(epsilon=float, sigma=float, len_keys=1))
r_cut = TypeParameter("r_cut", "special_pair_types",
TypeParameterDict(float, len_keys=1))
self._extend_typeparam([params, r_cut])
def typeparam():
return TypeParameter(name='type_param',
type_kind='particle_types',
param_dict=TypeParameterDict(
foo=1, bar=identity,
len_keys=1)
)
def __init__(self):
params = TypeParameter(
"params", "bond_types",
TypeParameterDict(k=float,
r0=float,
epsilon=float,
sigma=float,
len_keys=1))
self._add_typeparam(params)
def __init__(self, default_step_size=None):
if default_step_size is None:
step_size = float
else:
step_size = float(default_step_size)
typeparam_step_size = TypeParameter('step_size',
type_kind='particle_types',
param_dict=TypeParameterDict(
step_size, len_keys=1))
self._add_typeparam(typeparam_step_size)
def __init__(self, default_step_size=None, vertex_move_probability=1):
super().__init__(default_step_size)
param_dict = ParameterDict(
vertex_move_probability=float(vertex_move_probability))
self._param_dict.update(param_dict)
typeparam_volume = TypeParameter('volume',
type_kind='particle_types',
param_dict=TypeParameterDict(
float, len_keys=1))
self._add_typeparam(typeparam_volume)
def __init__(self, nlist, default_r_cut=None):
super().__init__()
r_cut_param = TypeParameter(
'r_cut', 'particle_types',
TypeParameterDict(positive_real, len_keys=2))
if default_r_cut is not None:
r_cut_param.default = default_r_cut
self._add_typeparam(r_cut_param)
self._param_dict.update(ParameterDict(nlist=hoomd.md.nlist.NList))
self.nlist = nlist
def __init__(self, filter):
super().__init__()
# store metadata
param_dict = ParameterDict(filter=ParticleFilter)
param_dict["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):
body = TypeParameter(
"body", "particle_types",
TypeParameterDict(OnlyIf(to_type_converter({
'constituent_types': [str],
'positions': [(float, ) * 3],
'orientations': [(float, ) * 4],
'charges': [float],
'diameters': [float]
}),
allow_none=True),
len_keys=1))
self._add_typeparam(body)
self.body.default = None
def __init__(self, filter, kT, manifold_constraint=None, tolerance=0.000001, alpha=None):
# store metadata
param_dict = ParameterDict(
filter=ParticleFilter,
kT=Variant,
alpha=OnlyTypes(float, allow_none=True),
)
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])
super().__init__(manifold_constraint,tolerance)
def __init__(self,
callback,
default_step_size=None,
param_move_probability=1):
super().__init__(default_step_size)
param_dict = ParameterDict(
param_move_probability=float(param_move_probability),
callback=object)
param_dict["callback"] = callback
self._param_dict.update(param_dict)
typeparam_shapeparams = TypeParameter('params',
type_kind='particle_types',
param_dict=TypeParameterDict(
[float], len_keys=1))
self._add_typeparam(typeparam_shapeparams)
