def __init__(self, origin=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 1.0), inside=True): self._origin = _hoomd.make_scalar3(*origin) self._normal = _hoomd.make_scalar3(*normal) self.inside = inside
def __init__(self, r=0.0, origin=(0.0, 0.0, 0.0), axis=(0.0, 0.0, 1.0), inside=True): self.r = r self._origin = _hoomd.make_scalar3(*origin) self._axis = _hoomd.make_scalar3(*axis) self.inside = inside
def __init__(self, group, constraint_vector=[0, 0, 1]): if (constraint_vector[0]**2 + constraint_vector[1]**2 + constraint_vector[2]**2) < 1e-10: raise RuntimeError("The one dimension constraint vector is zero") constraint_vector = _hoomd.make_scalar3(constraint_vector[0], constraint_vector[1], constraint_vector[2]) hoomd.util.print_status_line() # initialize the base class _constraint_force.__init__(self) # create the c++ mirror class if not hoomd.context.exec_conf.isCUDAEnabled(): self.cpp_force = _md.OneDConstraint( hoomd.context.current.system_definition, group.cpp_group, constraint_vector) else: self.cpp_force = _md.OneDConstraintGPU( hoomd.context.current.system_definition, group.cpp_group, constraint_vector) hoomd.context.current.system.addCompute(self.cpp_force, self.force_name) # store metadata self.group = group self.constraint_vector = constraint_vector self.metadata_fields = ['group', 'constraint_vector']
def process_coeff(self, coeff): r_cut = coeff['r_cut']; epsilon = coeff['epsilon']; sigma = coeff['sigma']; alpha = coeff['alpha']; lj1 = 4.0 * epsilon * math.pow(sigma, 12.0); lj2 = alpha * 4.0 * epsilon * math.pow(sigma, 6.0); return _hoomd.make_scalar3(lj1, lj2,r_cut);
def process_coeff(self, coeff): epsilon = coeff['epsilon'] sigma = coeff['sigma'] delta = coeff['delta'] alpha = coeff['alpha'] lj1 = 4.0 * epsilon * math.pow(sigma, 12.0) lj2 = alpha * 4.0 * epsilon * math.pow(sigma, 6.0) return _hoomd.make_scalar3(lj1, lj2, delta)
def process_coeff(self, coeff): r_cut = coeff['r_cut']; epsilon = coeff['epsilon']; sigma = coeff['sigma']; alpha = coeff['alpha']; lj1 = 4.0 * epsilon * math.pow(sigma, 12.0); lj2 = alpha * 4.0 * epsilon * math.pow(sigma, 6.0); r_cut_squared = r_cut * r_cut return _hoomd.make_scalar3(lj1, lj2, r_cut_squared);
def process_coeff(self, coeff): amplitude = coeff['amp'] exponent = coeff['m'] r_start = coeff['r_start'] r_start_sq = r_start*r_start if exponent<2.0: hoomd.context.msg.error('azplugins.pair.spline: Exponent for spline needs to be >= 2.\n') raise ValueError('Exponent for spline needs to be >= 2') if r_start>=self.r_cut: hoomd.context.msg.error('azplugins.pair.spline: r_start needs to be smaller than r_cut.\n') raise ValueError('r_start needs to be smaller than r_cut') return _hoomd.make_scalar3(amplitude, exponent,r_start_sq)
def _attach(self): # initialize the reflected c++ class if isinstance(self._simulation.device, hoomd.device.CPU): my_class = _md.ActiveForceCompute else: my_class = _md.ActiveForceComputeGPU self._cpp_obj = my_class( self._simulation.state._cpp_sys_def, self._simulation.state._get_group(self.filter), self.seed, self.rotation_diff, _hoomd.make_scalar3(0, 0, 0), 0, 0, 0) # Attach param_dict and typeparam_dict super()._attach()
def __init__(self, F): try: if len(F) != 3: hoomd.context.current.device.cpp_msg.error('mpcd.force.constant: field must be a 3-component vector.\n') raise ValueError('External field must be a 3-component vector') except TypeError: hoomd.context.current.device.cpp_msg.error('mpcd.force.constant: field must be a 3-component vector.\n') raise ValueError('External field must be a 3-component vector') # initialize python level _force.__init__(self) self._F = F # initialize c++ self._cpp.ConstantForce(_hoomd.make_scalar3(self.F[0], self.F[1], self.F[2]))
def __init__(self, group, r=None, rx=None, ry=None, rz=None, P=(0, 0, 0)): period = 1 # Error out in MPI simulations if (hoomd.version.mpi_enabled): if hoomd.context.current.system_definition.getParticleData( ).getDomainDecomposition(): hoomd.context.current.device.cpp_msg.error( "constrain.ellipsoid is not supported in multi-processor " "simulations.\n\n") raise RuntimeError("Error initializing updater.") # Error out if no radii are set if (r is None and rx is None and ry is None and rz is None): hoomd.context.current.device.cpp_msg.error( "no radii were defined in update.constraint_ellipsoid.\n\n") raise RuntimeError("Error initializing updater.") # initialize the base class # _updater.__init__(self) # Set parameters P = _hoomd.make_scalar3(P[0], P[1], P[2]) if (r is not None): rx = ry = rz = r # create the c++ mirror class if not hoomd.context.current.device.cpp_exec_conf.isCUDAEnabled(): self.cpp_updater = _md.ConstraintEllipsoid( hoomd.context.current.system_definition, group.cpp_group, P, rx, ry, rz) else: self.cpp_updater = _md.ConstraintEllipsoidGPU( hoomd.context.current.system_definition, group.cpp_group, P, rx, ry, rz) self.setupUpdater(period) # store metadata self.group = group self.P = P self.rx = rx self.ry = ry self.rz = rz self.metadata_fields = ['group', 'P', 'rx', 'ry', 'rz']
def __init__(self, F): hoomd.util.print_status_line() try: if len(F) != 3: hoomd.context.msg.error('mpcd.force.constant: field must be a 3-component vector.\n') raise ValueError('External field must be a 3-component vector') except TypeError: hoomd.context.msg.error('mpcd.force.constant: field must be a 3-component vector.\n') raise ValueError('External field must be a 3-component vector') # initialize python level _force.__init__(self) self.metadata_fields += ['F'] self._F = F # initialize c++ self._cpp.ConstantForce(_hoomd.make_scalar3(self.F[0], self.F[1], self.F[2]))
def __init__(self, group, P, r): # initialize the base class _constraint_force.__init__(self); # create the c++ mirror class P = _hoomd.make_scalar3(P[0], P[1], P[2]); if not hoomd.context.current.device.cpp_exec_conf.isCUDAEnabled(): self.cpp_force = _md.ConstraintSphere(hoomd.context.current.system_definition, group.cpp_group, P, r); else: self.cpp_force = _md.ConstraintSphereGPU(hoomd.context.current.system_definition, group.cpp_group, P, r); hoomd.context.current.system.addCompute(self.cpp_force, self.force_name); # store metadata self.group = group self.P = P self.r = r self.metadata_fields = ['group','P', 'r']
def __call__(self, r): """ Computes the velocity profile Args: r (list): Position to evaluate profile Example:: >>> u = azplugins.flow.parabolic(U = 2.0, H = 0.5) >>> print u([0.0, 0.1, 0.3]) 2.0 >>> print u((0.5, -0.2, 1.6)) 0.0 """ hoomd.util.print_status_line() u = self._cpp(_hoomd.make_scalar3(r[0], r[1], r[2])) return (u.x, u.y, u.z)
def __init__(self, group, P, r): hoomd.util.print_status_line(); # initialize the base class _constraint_force.__init__(self); # create the c++ mirror class P = _hoomd.make_scalar3(P[0], P[1], P[2]); if not hoomd.context.exec_conf.isCUDAEnabled(): self.cpp_force = _md.ConstraintSphere(hoomd.context.current.system_definition, group.cpp_group, P, r); else: self.cpp_force = _md.ConstraintSphereGPU(hoomd.context.current.system_definition, group.cpp_group, P, r); hoomd.context.current.system.addCompute(self.cpp_force, self.force_name); # store metadata self.group = group self.P = P self.r = r self.metadata_fields = ['group','P', 'r']
def __init__(self, group, r=None, rx=None, ry=None, rz=None, P=(0,0,0)): hoomd.util.print_status_line(); period = 1; # Error out in MPI simulations if (_hoomd.is_MPI_available()): if context.current.system_definition.getParticleData().getDomainDecomposition(): context.msg.error("constrain.ellipsoid is not supported in multi-processor simulations.\n\n") raise RuntimeError("Error initializing updater.") # Error out if no radii are set if (r is None and rx is None and ry is None and rz is None): context.msg.error("no radii were defined in update.constraint_ellipsoid.\n\n") raise RuntimeError("Error initializing updater.") # initialize the base class _updater.__init__(self); # Set parameters P = _hoomd.make_scalar3(P[0], P[1], P[2]); if (r is not None): rx = ry = rz = r # create the c++ mirror class if not hoomd.context.exec_conf.isCUDAEnabled(): self.cpp_updater = _md.ConstraintEllipsoid(hoomd.context.current.system_definition, group.cpp_group, P, rx, ry, rz); else: self.cpp_updater = _md.ConstraintEllipsoidGPU(hoomd.context.current.system_definition, group.cpp_group, P, rx, ry, rz); self.setupUpdater(period); # store metadata self.group = group self.P = P self.rx = rx self.ry = ry self.rz = rz self.metadata_fields = ['group','P', 'rx', 'ry', 'rz']
def __init__(self, group, constraint_vector=[0,0,1]): if (constraint_vector[0]**2 + constraint_vector[1]**2 + constraint_vector[2]**2) < 1e-10: raise RuntimeError("The one dimension constraint vector is zero"); constraint_vector = _hoomd.make_scalar3(constraint_vector[0], constraint_vector[1], constraint_vector[2]); hoomd.util.print_status_line(); # initialize the base class _constraint_force.__init__(self); # create the c++ mirror class if not hoomd.context.exec_conf.isCUDAEnabled(): self.cpp_force = _md.OneDConstraint(hoomd.context.current.system_definition, group.cpp_group, constraint_vector); else: self.cpp_force = _md.OneDConstraintGPU(hoomd.context.current.system_definition, group.cpp_group, constraint_vector); hoomd.context.current.system.addCompute(self.cpp_force, self.force_name); # store metadata self.group = group self.constraint_vector = constraint_vector self.metadata_fields = ['group','constraint_vector']
def process_field_coeff(self, field): return _hoomd.make_scalar3(field[0],field[1],field[2])
def process_field_coeff(self, field): return _hoomd.make_scalar3(field[0], field[1], field[2])
def __init__(self, r=0.0, origin=(0.0, 0.0, 0.0), axis=(0.0, 0.0, 1.0), inside=True): self.r = r; self._origin = _hoomd.make_scalar3(*origin); self._axis = _hoomd.make_scalar3(*axis); self.inside = inside;
def set_param(self, type_name, types, positions, orientations=None, charges=None, diameters=None): R""" Set constituent particle types and coordinates for a rigid body. Args: type_name (str): The type of the central particle types (list): List of types of constituent particles positions (list): List of relative positions of constituent particles orientations (list): List of orientations of constituent particles (**optional**) charge (list): List of charges of constituent particles (**optional**) diameters (list): List of diameters of constituent particles (**optional**) .. caution:: The constituent particle type must be exist. If it does not exist, it can be created on the fly using ``system.particles.types.add('A_const')`` (see :py:mod:`hoomd.data`). Example:: rigid = constrain.rigd() rigid.set_param('A', types = ['A_const', 'A_const'], positions = [(0,0,1),(0,0,-1)]) rigid.set_param('B', types = ['B_const', 'B_const'], positions = [(0,0,.5),(0,0,-.5)]) """ # get a list of types from the particle data ntypes = hoomd.context.current.system_definition.getParticleData( ).getNTypes() type_list = [] for i in range(0, ntypes): type_list.append(hoomd.context.current.system_definition. getParticleData().getNameByType(i)) if type_name not in type_list: hoomd.context.msg.error('Type ' '{}' ' not found.\n'.format(type_name)) raise RuntimeError( 'Error setting up parameters for constrain.rigid()') type_id = type_list.index(type_name) if not isinstance(types, list): hoomd.context.msg.error('Expecting list of particle types.\n') raise RuntimeError( 'Error setting up parameters for constrain.rigid()') type_vec = _hoomd.std_vector_uint() for t in types: if t not in type_list: hoomd.context.msg.error('Type ' '{}' ' not found.\n'.format(t)) raise RuntimeError( 'Error setting up parameters for constrain.rigid()') constituent_type_id = type_list.index(t) type_vec.append(constituent_type_id) pos_vec = _hoomd.std_vector_scalar3() positions_list = list(positions) for p in positions_list: p = tuple(p) if len(p) != 3: hoomd.context.msg.error( 'Particle position is not a coordinate triple.\n') raise RuntimeError( 'Error setting up parameters for constrain.rigid()') pos_vec.append(_hoomd.make_scalar3(p[0], p[1], p[2])) orientation_vec = _hoomd.std_vector_scalar4() if orientations is not None: orientations_list = list(orientations) for o in orientations_list: o = tuple(o) if len(o) != 4: hoomd.context.msg.error( 'Particle orientation is not a 4-tuple.\n') raise RuntimeError( 'Error setting up parameters for constrain.rigid()') orientation_vec.append( _hoomd.make_scalar4(o[0], o[1], o[2], o[3])) else: for p in positions: orientation_vec.append(_hoomd.make_scalar4(1, 0, 0, 0)) charge_vec = _hoomd.std_vector_scalar() if charges is not None: charges_list = list(charges) for c in charges_list: charge_vec.append(float(c)) else: for p in positions: charge_vec.append(0.0) diameter_vec = _hoomd.std_vector_scalar() if diameters is not None: diameters_list = list(diameters) for d in diameters_list: diameter_vec.append(float(d)) else: for p in positions: diameter_vec.append(1.0) # set parameters in C++ force self.cpp_force.setParam(type_id, type_vec, pos_vec, orientation_vec, charge_vec, diameter_vec)
def normal(self, normal): self._normal = _hoomd.make_scalar3(*normal)
def origin(self, origin): self._origin = _hoomd.make_scalar3(*origin);
def set_param(self,type_name, types, positions, orientations=None, charges=None, diameters=None): R""" Set constituent particle types and coordinates for a rigid body. Args: type_name (str): The type of the central particle types (list): List of types of constituent particles positions (list): List of relative positions of constituent particles orientations (list): List of orientations of constituent particles (**optional**) charge (list): List of charges of constituent particles (**optional**) diameters (list): List of diameters of constituent particles (**optional**) .. caution:: The constituent particle type must be exist. If it does not exist, it can be created on the fly using ``system.particles.types.add('A_const')`` (see :py:mod:`hoomd.data`). Example:: rigid = constrain.rigd() rigid.set_param('A', types = ['A_const', 'A_const'], positions = [(0,0,1),(0,0,-1)]) rigid.set_param('B', types = ['B_const', 'B_const'], positions = [(0,0,.5),(0,0,-.5)]) """ # get a list of types from the particle data ntypes = hoomd.context.current.system_definition.getParticleData().getNTypes(); type_list = []; for i in range(0,ntypes): type_list.append(hoomd.context.current.system_definition.getParticleData().getNameByType(i)); if type_name not in type_list: hoomd.context.msg.error('Type ''{}'' not found.\n'.format(type_name)) raise RuntimeError('Error setting up parameters for constrain.rigid()') type_id = type_list.index(type_name) if not isinstance(types, list): hoomd.context.msg.error('Expecting list of particle types.\n') raise RuntimeError('Error setting up parameters for constrain.rigid()') type_vec = _hoomd.std_vector_uint() for t in types: if t not in type_list: hoomd.context.msg.error('Type ''{}'' not found.\n'.format(t)) raise RuntimeError('Error setting up parameters for constrain.rigid()') constituent_type_id = type_list.index(t) type_vec.append(constituent_type_id) pos_vec = _hoomd.std_vector_scalar3() positions_list = list(positions) for p in positions_list: p = tuple(p) if len(p) != 3: hoomd.context.msg.error('Particle position is not a coordinate triple.\n') raise RuntimeError('Error setting up parameters for constrain.rigid()') pos_vec.append(_hoomd.make_scalar3(p[0],p[1],p[2])) orientation_vec = _hoomd.std_vector_scalar4() if orientations is not None: orientations_list = list(orientations) for o in orientations_list: o = tuple(o) if len(o) != 4: hoomd.context.msg.error('Particle orientation is not a 4-tuple.\n') raise RuntimeError('Error setting up parameters for constrain.rigid()') orientation_vec.append(_hoomd.make_scalar4(o[0], o[1], o[2], o[3])) else: for p in positions: orientation_vec.append(_hoomd.make_scalar4(1,0,0,0)) charge_vec = _hoomd.std_vector_scalar() if charges is not None: charges_list = list(charges) for c in charges_list: charge_vec.append(float(c)) else: for p in positions: charge_vec.append(0.0) diameter_vec = _hoomd.std_vector_scalar() if diameters is not None: diameters_list = list(diameters) for d in diameters_list: diameter_vec.append(float(d)) else: for p in positions: diameter_vec.append(1.0) # set parameters in C++ force self.cpp_force.setParam(type_id, type_vec, pos_vec, orientation_vec, charge_vec, diameter_vec)
def __init__(self, origin=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 1.0), inside=True): self._origin = _hoomd.make_scalar3(*origin); self._normal = _hoomd.make_scalar3(*normal); self.inside = inside;
def process_coeff(self, coeff): a = coeff['A'] gamma = coeff['gamma'] s = coeff['s'] return _hoomd.make_scalar3(a, gamma, s)
def _attach(self): self._cpp_obj = _md.ManifoldSphere(self.r, _hoomd.make_scalar3( self.P[0], self.P[1], self.P[2]) ); super()._attach()
def axis(self, axis): self._axis = _hoomd.make_scalar3(*axis);
def __init__(self, seed, group, f_lst=None, t_lst=None, orientation_link=True, orientation_reverse_link=False, rotation_diff=0, constraint=None): hoomd.util.print_status_line() # initialize the base class _force.__init__(self) if (f_lst is None) and (t_lst is None): raise RuntimeError('No forces or torques are being set') # input check if (f_lst is not None): for element in f_lst: if type(element) != tuple or len(element) != 3: raise RuntimeError( "Active force passed in should be a list of 3-tuples (fx, fy, fz)" ) else: f_lst = [] for element in t_lst: f_lst.append((0, 0, 0)) if (t_lst is not None): for element in t_lst: if type(element) != tuple or len(element) != 3: raise RuntimeError( "Active torque passed in should be a list of 3-tuples (tx, ty, tz)" ) else: t_lst = [] for element in f_lst: t_lst.append((0, 0, 0)) # assign constraints if (constraint is not None): if (constraint.__class__.__name__ == "constraint_ellipsoid"): P = constraint.P rx = constraint.rx ry = constraint.ry rz = constraint.rz else: raise RuntimeError( "Active force constraint is not accepted (currently only accepts ellipsoids)" ) else: P = _hoomd.make_scalar3(0, 0, 0) rx = 0 ry = 0 rz = 0 # create the c++ mirror class if not hoomd.context.exec_conf.isCUDAEnabled(): self.cpp_force = _md.ActiveForceCompute( hoomd.context.current.system_definition, group.cpp_group, seed, f_lst, t_lst, orientation_link, orientation_reverse_link, rotation_diff, P, rx, ry, rz) else: self.cpp_force = _md.ActiveForceComputeGPU( hoomd.context.current.system_definition, group.cpp_group, seed, f_lst, t_lst, orientation_link, orientation_reverse_link, rotation_diff, P, rx, ry, rz) # store metadata self.metadata_fields = [ 'group', 'seed', 'orientation_link', 'rotation_diff', 'constraint' ] self.group = group self.seed = seed self.orientation_link = orientation_link self.orientation_reverse_link = orientation_reverse_link self.rotation_diff = rotation_diff self.constraint = constraint hoomd.context.current.system.addCompute(self.cpp_force, self.force_name)
def axis(self, axis): self._axis = _hoomd.make_scalar3(*axis)
def normal(self, normal): self._normal = _hoomd.make_scalar3(*normal);
def origin(self, origin): self._origin = _hoomd.make_scalar3(*origin)
def _attach(self): self._cpp_obj = _md.ManifoldEllipsoid( self.a, self.b, self.c, _hoomd.make_scalar3(self.P[0], self.P[1], self.P[2])) super()._attach()
def __init__(self, seed, group, f_lst=None, t_lst=None, orientation_link=True, orientation_reverse_link=False, rotation_diff=0, constraint=None): hoomd.util.print_status_line(); # initialize the base class _force.__init__(self); if (f_lst is None) and (t_lst is None): raise RuntimeError('No forces or torques are being set') # input check if (f_lst is not None): for element in f_lst: if type(element) != tuple or len(element) != 3: raise RuntimeError("Active force passed in should be a list of 3-tuples (fx, fy, fz)") else: f_lst = [] for element in t_lst: f_lst.append((0,0,0)) if (t_lst is not None): for element in t_lst: if type(element) != tuple or len(element) != 3: raise RuntimeError("Active torque passed in should be a list of 3-tuples (tx, ty, tz)") else: t_lst = [] for element in f_lst: t_lst.append((0,0,0)) # assign constraints if (constraint is not None): if (constraint.__class__.__name__ is "constraint_ellipsoid"): P = constraint.P rx = constraint.rx ry = constraint.ry rz = constraint.rz else: raise RuntimeError("Active force constraint is not accepted (currently only accepts ellipsoids)") else: P = _hoomd.make_scalar3(0, 0, 0) rx = 0 ry = 0 rz = 0 # create the c++ mirror class if not hoomd.context.exec_conf.isCUDAEnabled(): self.cpp_force = _md.ActiveForceCompute(hoomd.context.current.system_definition, group.cpp_group, seed, f_lst, t_lst, orientation_link, orientation_reverse_link, rotation_diff, P, rx, ry, rz); else: self.cpp_force = _md.ActiveForceComputeGPU(hoomd.context.current.system_definition, group.cpp_group, seed, f_lst, t_lst, orientation_link, orientation_reverse_link, rotation_diff, P, rx, ry, rz); # store metadata self.metdata_fields = ['group', 'seed', 'orientation_link', 'rotation_diff', 'constraint'] self.group = group self.seed = seed self.orientation_link = orientation_link self.orientation_reverse_link = orientation_reverse_link self.rotation_diff = rotation_diff self.constraint = constraint hoomd.context.current.system.addCompute(self.cpp_force, self.force_name);
def _attach(self): self._cpp_obj = _md.ManifoldZCylinder( self.r, _hoomd.make_scalar3(self.P[0], self.P[1], self.P[2])) super()._attach()
def __init__(self, r=0.0, origin=(0.0, 0.0, 0.0), inside=True): self.r = r; self._origin = _hoomd.make_scalar3(*origin); self.inside = inside;
def process_coeff(self, coeff): v0 = coeff['v0'] eps = coeff['eps'] scaledr_cut = coeff['scaledr_cut'] return _hoomd.make_scalar3(v0, eps, scaledr_cut)