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