def run(tsteps, profile=False, limit_hours=None, limit_multiple=1, callback_period=0, callback=None, quiet=False): if not quiet: _util.print_status_line() # check if initialization has occured if not init.is_initialized(): globals.msg.error("Cannot run before initialization\n") raise RuntimeError('Error running') if globals.integrator is None: globals.msg.warning("Starting a run without an integrator set") else: globals.integrator.update_forces() globals.integrator.update_methods() globals.integrator.update_thermos() # update autotuner parameters globals.system.setAutotunerParams(globals.options.autotuner_enable, int(globals.options.autotuner_period)) # if rigid bodies, setxv if len(data.system_data(globals.system_definition).bodies) > 0: data.system_data(globals.system_definition).bodies.updateRV() for logger in globals.loggers: logger.update_quantities() globals.system.enableProfiler(profile) globals.system.enableQuietRun(quiet) if globals.neighbor_list: globals.neighbor_list.update_rcut() globals.neighbor_list.update_exclusions_defaults() # update all user-defined neighbor lists for nl in globals.neighbor_lists: nl.update_rcut() nl.update_exclusions_defaults() # detect 0 hours remaining properly if limit_hours == 0.0: globals.msg.warning( "Requesting a run() with a 0 time limit, doing nothing.\n") return if limit_hours is None: limit_hours = 0.0 if not quiet: globals.msg.notice(1, "** starting run **\n") globals.system.run(int(tsteps), callback_period, callback, limit_hours, int(limit_multiple)) if not quiet: globals.msg.notice(1, "** run complete **\n")
def run(tsteps, profile=False, limit_hours=None, limit_multiple=1, callback_period=0, callback=None, quiet=False): if not quiet: _util.print_status_line(); # check if initialization has occured if not init.is_initialized(): globals.msg.error("Cannot run before initialization\n"); raise RuntimeError('Error running'); if globals.integrator is None: globals.msg.warning("Starting a run without an integrator set"); else: globals.integrator.update_forces(); globals.integrator.update_methods(); globals.integrator.update_thermos(); # update autotuner parameters globals.system.setAutotunerParams(globals.options.autotuner_enable, int(globals.options.autotuner_period)); # if rigid bodies, setxv if len(data.system_data(globals.system_definition).bodies) > 0: data.system_data(globals.system_definition).bodies.updateRV() for logger in globals.loggers: logger.update_quantities(); globals.system.enableProfiler(profile); globals.system.enableQuietRun(quiet); if globals.neighbor_list: globals.neighbor_list.update_rcut(); globals.neighbor_list.update_exclusions_defaults(); # update all user-defined neighbor lists for nl in globals.neighbor_lists: nl.update_rcut() nl.update_exclusions_defaults() # detect 0 hours remaining properly if limit_hours == 0.0: globals.msg.warning("Requesting a run() with a 0 time limit, doing nothing.\n"); return; if limit_hours is None: limit_hours = 0.0 if not quiet: globals.msg.notice(1, "** starting run **\n"); globals.system.run(int(tsteps), callback_period, callback, limit_hours, int(limit_multiple)); if not quiet: globals.msg.notice(1, "** run complete **\n");
def read_bin(filename, time_step=None): util.print_status_line() globals.msg.warning("init.read_bin is deprecated and will be removed in the next release") # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf() # check if initialization has already occurred if is_initialized(): globals.msg.error("Cannot initialize more than once\n") raise RuntimeError("Error initializing") # read in the data initializer = hoomd.HOOMDBinaryInitializer(my_exec_conf, filename) snapshot = initializer.getSnapshot() my_domain_decomposition = _create_domain_decomposition(snapshot.global_box) if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf, my_domain_decomposition) else: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf) # initialize the system if time_step is None: globals.system = hoomd.System(globals.system_definition, initializer.getTimeStep()) else: globals.system = hoomd.System(globals.system_definition, time_step) _perform_common_init_tasks() return data.system_data(globals.system_definition)
def read_xml(filename, time_step=None, wrap_coordinates=False): util.print_status_line() # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf() # check if initialization has already occured if is_initialized(): globals.msg.error("Cannot initialize more than once\n") raise RuntimeError("Error creating random polymers") # read in the data initializer = hoomd.HOOMDInitializer(my_exec_conf, filename, wrap_coordinates) snapshot = initializer.getSnapshot() my_domain_decomposition = _create_domain_decomposition(snapshot.global_box) if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf, my_domain_decomposition) else: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf) # initialize the system if time_step is None: globals.system = hoomd.System(globals.system_definition, initializer.getTimeStep()) else: globals.system = hoomd.System(globals.system_definition, time_step) _perform_common_init_tasks() return data.system_data(globals.system_definition)
def recursivelyMark(self,nodeID, nodes, local_bonds=None, local_id=None, bond_type=None, local_types=None): system = data.system_data(globals.system_definition) (connections, visited) = nodes[nodeID] if visited: return connectedNodeID = local_id if local_id is None: local_id = -1 local_id += 1 if not local_types: local_types = [] if not local_bonds: local_bonds = [] if connectedNodeID is not None: local_bonds.append((connectedNodeID,local_id,bond_type)) # mark as visited nodes[nodeID][1] = True local_types.append(system.particles[nodeID].type) for (next_connectedNodeID,next_bond_type) in connections: ret = self.recursivelyMark(next_connectedNodeID, nodes, local_bonds, local_id, next_bond_type, local_types) if ret is not None: ((local_bonds,local_types),local_id) = ret return ((local_bonds,local_types),local_id)
def create_empty(N, box, n_particle_types=1, n_bond_types=0, n_angle_types=0, n_dihedral_types=0, n_improper_types=0): util.print_status_line() # check if initialization has already occurred if is_initialized(): globals.msg.error("Cannot initialize more than once\n") raise RuntimeError('Error initializing') my_exec_conf = _create_exec_conf() # create the empty system boxdim = hoomd.BoxDim(float(box[0]), float(box[1]), float(box[2])) my_domain_decomposition = _create_domain_decomposition(boxdim) if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition( N, boxdim, n_particle_types, n_bond_types, n_angle_types, n_dihedral_types, n_improper_types, my_exec_conf, my_domain_decomposition) else: globals.system_definition = hoomd.SystemDefinition( N, boxdim, n_particle_types, n_bond_types, n_angle_types, n_dihedral_types, n_improper_types, my_exec_conf) # initialize the system globals.system = hoomd.System(globals.system_definition, 0) _perform_common_init_tasks() return data.system_data(globals.system_definition)
def read_xml(filename, time_step=None, wrap_coordinates=False): util.print_status_line() # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf() # check if initialization has already occured if is_initialized(): globals.msg.error("Cannot initialize more than once\n") raise RuntimeError("Error creating random polymers") # read in the data initializer = hoomd.HOOMDInitializer(my_exec_conf, filename, wrap_coordinates) snapshot = initializer.getSnapshot() my_domain_decomposition = _create_domain_decomposition(snapshot.global_box) if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf, my_domain_decomposition) else: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf) # initialize the system if time_step is None: globals.system = hoomd.System(globals.system_definition, initializer.getTimeStep()) else: globals.system = hoomd.System(globals.system_definition, time_step) _perform_common_init_tasks() return data.system_data(globals.system_definition)
def find_distinct_species(self): # nodes correspond to particles # bonds are connections between nodes nodes = []; system = data.system_data(globals.system_definition) nparticles = len(system.particles) for p in range(0,nparticles): nodes.append([[], False]) for bond in system.bonds: btype = globals.system_definition.getBondData().getTypeByName(bond.type) nodes[bond.a][0].append((bond.b, btype)); nodes[bond.b][0].append((bond.a, btype)); # find distinct connected components species = {}; for (nodeID, (connections, visited)) in enumerate(nodes): if visited == False: (this_species, natoms) = self.recursivelyMark(nodeID, nodes) this_species = tuple([tuple(sublist) for sublist in this_species]) if this_species not in species.keys(): species[this_species]=[1, natoms+1] else: species[this_species][0]+=1; return species;
def read_snapshot(snapshot): util.print_status_line() # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf() # check if initialization has already occured if is_initialized(): globals.msg.error("Cannot initialize more than once\n") raise RuntimeError("Error creating random polymers") my_domain_decomposition = _create_domain_decomposition(snapshot.global_box) if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf, my_domain_decomposition) else: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf) # initialize the system globals.system = hoomd.System(globals.system_definition, 0) _perform_common_init_tasks() return data.system_data(globals.system_definition)
def read_bin(filename, time_step=None): util.print_status_line() globals.msg.warning( "init.read_bin is deprecated and will be removed in the next release") # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf() # check if initialization has already occurred if is_initialized(): globals.msg.error("Cannot initialize more than once\n") raise RuntimeError('Error initializing') # read in the data initializer = hoomd.HOOMDBinaryInitializer(my_exec_conf, filename) snapshot = initializer.getSnapshot() my_domain_decomposition = _create_domain_decomposition(snapshot.global_box) if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf, my_domain_decomposition) else: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf) # initialize the system if time_step is None: globals.system = hoomd.System(globals.system_definition, initializer.getTimeStep()) else: globals.system = hoomd.System(globals.system_definition, time_step) _perform_common_init_tasks() return data.system_data(globals.system_definition)
def read_bin(filename): util.print_status_line(); # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf(); # check if initialization has already occurred if is_initialized(): globals.msg.error("Cannot initialize more than once\n"); raise RuntimeError('Error initializing'); # read in the data initializer = hoomd.HOOMDBinaryInitializer(my_exec_conf,filename); snapshot = initializer.getSnapshot() my_domain_decomposition = _create_domain_decomposition(snapshot.global_box); if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf, my_domain_decomposition); else: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf); # initialize the system if time_step is None: globals.system = hoomd.System(globals.system_definition, initializer.getTimeStep()); else: globals.system = hoomd.System(globals.system_definition, time_step); _perform_common_init_tasks(); return data.system_data(globals.system_definition);
def create_empty(N, box, n_particle_types=1, n_bond_types=0, n_angle_types=0, n_dihedral_types=0, n_improper_types=0): util.print_status_line(); # check if initialization has already occurred if is_initialized(): globals.msg.error("Cannot initialize more than once\n"); raise RuntimeError('Error initializing'); my_exec_conf = _create_exec_conf(); # create the empty system boxdim = hoomd.BoxDim(float(box[0]), float(box[1]), float(box[2])); globals.system_definition = hoomd.SystemDefinition(N, boxdim, n_particle_types, n_bond_types, n_angle_types, n_dihedral_types, n_improper_types, my_exec_conf); # initialize the system globals.system = hoomd.System(globals.system_definition, 0); _perform_common_init_tasks(); return data.system_data(globals.system_definition);
def create_random(N, phi_p=None, name="A", min_dist=0.7, box=None, seed=1): util.print_status_line(); # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf(); # check if initialization has already occured if is_initialized(): globals.msg.error("Cannot initialize more than once\n"); raise RuntimeError("Error initializing"); # abuse the polymer generator to generate single particles if phi_p is not None: # calculate the box size L = math.pow(math.pi/6.0*N / phi_p, 1.0/3.0); box = data.boxdim(L=L); if box is None: raise RuntimeError('box or phi_p must be specified'); if not isinstance(box, data.boxdim): globals.msg.error('box must be a data.boxdim object'); raise TypeError('box must be a data.boxdim object'); # create the generator generator = hoomd.RandomGenerator(my_exec_conf, box._getBoxDim(), seed, box.dimensions); # build type list type_vector = hoomd.std_vector_string(); type_vector.append(name); # empty bond lists for single particles bond_ab = hoomd.std_vector_uint(); bond_type = hoomd.std_vector_string(); # create the generator generator.addGenerator(int(N), hoomd.PolymerParticleGenerator(my_exec_conf, 1.0, type_vector, bond_ab, bond_ab, bond_type, 100, box.dimensions)); # set the separation radius generator.setSeparationRadius(name, min_dist/2.0); # generate the particles generator.generate(); # initialize snapshot snapshot = generator.getSnapshot() my_domain_decomposition = _create_domain_decomposition(snapshot.global_box); if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf, my_domain_decomposition); else: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf); # initialize the system globals.system = hoomd.System(globals.system_definition, 0); _perform_common_init_tasks(); return data.system_data(globals.system_definition);
def create_empty(N, box, particle_types=['A'], bond_types=[], angle_types=[], dihedral_types=[], improper_types=[]): util.print_status_line(); # check if initialization has already occurred if is_initialized(): globals.msg.error("Cannot initialize more than once\n"); raise RuntimeError('Error initializing'); my_exec_conf = _create_exec_conf(); # create the empty system if not isinstance(box, data.boxdim): globals.msg.error('box must be a data.boxdim object'); raise TypeError('box must be a data.boxdim object'); boxdim = box._getBoxDim(); my_domain_decomposition = _create_domain_decomposition(boxdim); if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition(N, boxdim, len(particle_types), len(bond_types), len(angle_types), len(dihedral_types), len(improper_types), my_exec_conf, my_domain_decomposition); else: globals.system_definition = hoomd.SystemDefinition(N, boxdim, len(particle_types), len(bond_types), len(angle_types), len(dihedral_types), len(improper_types), my_exec_conf) globals.system_definition.setNDimensions(box.dimensions); # transfer names to C++ for i,name in enumerate(particle_types): globals.system_definition.getParticleData().setTypeName(i,name); for i,name in enumerate(bond_types): globals.system_definition.getBondData().setTypeName(i,name); for i,name in enumerate(angle_types): globals.system_definition.getAngleData().setTypeName(i,name); for i,name in enumerate(dihedral_types): globals.system_definition.getDihedralData().setTypeName(i,name); for i,name in enumerate(improper_types): globals.system_definition.getImproperData().setTypeName(i,name); # initialize the system globals.system = hoomd.System(globals.system_definition, 0); _perform_common_init_tasks(); return data.system_data(globals.system_definition);
def create_random(N, phi_p, name="A", min_dist=0.7): util.print_status_line() # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf() # check if initialization has already occured if is_initialized(): globals.msg.error("Cannot initialize more than once\n") raise RuntimeError("Error initializing") # abuse the polymer generator to generate single particles # calculat the box size L = math.pow(math.pi / 6.0 * N / phi_p, 1.0 / 3.0) box = hoomd.BoxDim(L) # create the generator generator = hoomd.RandomGenerator(my_exec_conf, box, 12345) # build type list type_vector = hoomd.std_vector_string() type_vector.append(name) # empty bond lists for single particles bond_ab = hoomd.std_vector_uint() bond_type = hoomd.std_vector_string() # create the generator generator.addGenerator( int(N), hoomd.PolymerParticleGenerator(my_exec_conf, 1.0, type_vector, bond_ab, bond_ab, bond_type, 100)) # set the separation radius generator.setSeparationRadius(name, min_dist / 2.0) # generate the particles generator.generate() # initialize snapshot snapshot = generator.getSnapshot() my_domain_decomposition = _create_domain_decomposition(snapshot.global_box) if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf, my_domain_decomposition) else: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf) # initialize the system globals.system = hoomd.System(globals.system_definition, 0) _perform_common_init_tasks() return data.system_data(globals.system_definition)
def create_empty(N, box, particle_types=['A'], bond_types=[], angle_types=[], dihedral_types=[], improper_types=[]): util.print_status_line() # check if initialization has already occurred if is_initialized(): globals.msg.error("Cannot initialize more than once\n") raise RuntimeError('Error initializing') my_exec_conf = _create_exec_conf() # create the empty system if not isinstance(box, data.boxdim): globals.msg.error('box must be a data.boxdim object') raise TypeError('box must be a data.boxdim object') boxdim = box._getBoxDim() my_domain_decomposition = _create_domain_decomposition(boxdim) if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition( N, boxdim, len(particle_types), len(bond_types), len(angle_types), len(dihedral_types), len(improper_types), my_exec_conf, my_domain_decomposition) else: globals.system_definition = hoomd.SystemDefinition( N, boxdim, len(particle_types), len(bond_types), len(angle_types), len(dihedral_types), len(improper_types), my_exec_conf) globals.system_definition.setNDimensions(box.dimensions) # transfer names to C++ for i, name in enumerate(particle_types): globals.system_definition.getParticleData().setTypeName(i, name) for i, name in enumerate(bond_types): globals.system_definition.getBondData().setTypeName(i, name) for i, name in enumerate(angle_types): globals.system_definition.getAngleData().setTypeName(i, name) for i, name in enumerate(dihedral_types): globals.system_definition.getDihedralData().setTypeName(i, name) for i, name in enumerate(improper_types): globals.system_definition.getImproperData().setTypeName(i, name) # initialize the system globals.system = hoomd.System(globals.system_definition, 0) _perform_common_init_tasks() return data.system_data(globals.system_definition)
def read_snapshot(snapshot): util.print_status_line(); # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf(); # check if initialization has already occured if is_initialized(): globals.msg.error("Cannot initialize more than once\n"); raise RuntimeError("Error creating random polymers"); my_domain_decomposition = _create_domain_decomposition(snapshot.global_box); if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf, my_domain_decomposition); else: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf); # initialize the system globals.system = hoomd.System(globals.system_definition, time_step); _perform_common_init_tasks(); return data.system_data(globals.system_definition);
def generate_parameters(self): system = data.system_data(globals.system_definition) parameters = "MdSimulation{\n" parameters += " FileMaster{\n" parameters += " commandFileName paramfile\n" parameters += " inputPrefix ./\n" parameters += " outputPrefix " + str(self.out_dir) + "/\n" parameters += " }\n" parameters += " nAtomType "+ str(len(system.particles.types)) + "\n" parameters += " nBondType "+ str(system.bonds.bdata.getNTypes()) + "\n" parameters += " atomTypes " for cur_type in system.particles.types: parameters += " " + cur_type + " 1.0"; # mass 1.0 parameters += "\n" parameters += " maskedPairPolicy" if (globals.neighbor_list.cpp_nlist.getNumExclusions(2) > 0): parameters += " MaskBonded\n" else: parameters += " MaskNone\n" parameters += " SpeciesManager{\n" for cur_species in self.species.keys(): parameters += " Species{\n" parameters += " moleculeCapacity " + str(self.species[cur_species][0]) + "\n" parameters += " nAtom " + str(self.species[cur_species][1]) + "\n" parameters += " nBond " + str(len(cur_species[0])) + "\n" parameters += " atomTypeIds\n" for cur_type in cur_species[1]: parameters += str(system.particles.types.index(cur_type)) + "\n" parameters += " speciesBonds\n" for cur_bond in cur_species[0]: parameters += str(cur_bond[0]) + " " + str(cur_bond[1]) + " " + str(cur_bond[2]) + "\n" parameters += " }\n" parameters += " }\n" parameters += " Random{\n" parameters += " seed 0\n" parameters += " }\n" parameters += " MdSystem{\n" # count pair forces num_pair_force = 0; for force in globals.forces: if force.enabled and isinstance(force, pair.pair): num_pair_force+=1 pair_force = force; if num_pair_force == 0 or num_pair_force > 1: print >> sys.stderr, "\n***Error! Only one pair force is supported in Simpatico"; raise RuntimeError('Error creating Simpatico parameter file'); parameters += " pairStyle" if (isinstance(pair_force, pair.lj)): parameters += " LJPair\n" pair_parameters = " epsilon" for typei in system.particles.types: for typej in system.particles.types: pair_parameters += " " + str(pair_force.pair_coeff.get(typei,typej,'epsilon')) pair_parameters += "\n" pair_parameters += " sigma" for typei in system.particles.types: for typej in system.particles.types: pair_parameters += " " + str(pair_force.pair_coeff.get(typei,typej,'sigma')) pair_parameters += "\n" pair_parameters += " cutoff" for typei in system.particles.types: for typej in system.particles.types: pair_parameters += " " + str(pair_force.pair_coeff.get(typei,typej,'r_cut')) pair_parameters += "\n" elif (isinstance(pair_force, pair.dpd_conservative)): parameters += " DpdPair\n" pair_parameters = " epsilon" for typei in system.particles.types: for typej in system.particles.types: pair_parameters += " " + str(pair_force.pair_coeff.get(typei,typej,'A')) pair_parameters += "\n" pair_parameters += " sigma" for typei in system.particles.types: for typej in system.particles.types: pair_parameters += " " + str(pair_force.pair_coeff.get(typei,typej,'r_cut')) pair_parameters += "\n" else: parameters += " LJPair\n" pair_parameters = " epsilon" for typei in system.particles.types: for typej in system.particles.types: pair_parameters += " 1.0" pair_parameters += "\n" pair_parameters += " sigma" for typei in system.particles.types: for typej in system.particles.types: pair_parameters += " 1.0" pair_parameters += "\n" pair_parameters += " cutoff" for typei in system.particles.types: for typej in system.particles.types: pair_parameters += " 1.0" pair_parameters += "\n" globals.msg.warning("Unsupported pair potential. Substituting default values.\n") # map bond potential parameters += " bondStyle" bond_force = None; for force in globals.forces: if isinstance(force,bond.harmonic) or isinstance(force,bond.fene): if bond_force is not None: print >> sys.stderr, "\n***Error! Only one bond force is supported"; raise RuntimeError('Error creating Simpatico parameter file'); bond_force = force nbondtypes = globals.system_definition.getBondData().getNTypes(); bond_type_list = []; for i in range(0,nbondtypes): bond_type_list.append(globals.system_definition.getBondData().getNameByType(i)); if isinstance(bond_force,bond.harmonic): parameters += " HarmonicBond\n" bond_parameters = " kappa" for type in bond_type_list: bond_parameters += " " + str(bond_force.bond_coeff.get(type,'k')) bond_parameters += "\n" bond_parameters += " length" for type in bond_type_list: bond_parameters += " " + str(bond_force.bond_coeff.get(type,'r0')) bond_parameters += "\n" else: print >> sys.stderr, "\n***Error! Unsupported bond potential"; raise RuntimeError('Error creating Simpatico parameter file'); parameters += " MdPairPotential{\n" parameters += pair_parameters # leave some room for fluctuations parameters += " maxBoundary orthorhombic " + str(2.0*system.box.Lx) + " " + str(2.0*system.box.Ly) + " " + str(2.0*system.box.Lz) + "\n" parameters += " PairList{\n" parameters += " atomCapacity " + str(len(system.particles)) + "\n" # adjust neighbors_per_atom if necessary neighbors_per_atom = 50 parameters += " pairCapacity " + str(len(system.particles)*neighbors_per_atom) + "\n" parameters += " skin .001\n " # any value > 0 parameters += " }\n" parameters += " }\n" parameters += " BondPotential{\n" parameters += bond_parameters parameters += " }\n" parameters += " EnergyEnsemble{\n" parameters += " type isothermal\n" # for post-processing we can choose any energy ensemble parameters += " temperature 1.0\n" parameters += " }\n" parameters += " BoundaryEnsemble{\n" parameters += " type rigid\n" # choose default boundary ensemble parameters += " }\n" parameters += " NvtNhIntegrator{\n" parameters += " dt 0.001\n" # standard values parameters += " tauT 1.0\n" parameters += " }\n" parameters += " }\n" # append definition of diagnostic manager parameters += " AnalyzerManager{\n" parameters += " baseInterval 1\n" if self.diagnostic_params is not None: parameters += self.diagnostic_params parameters += " }\n" parameters += " saveInterval 0\n" parameters += "}\n" return parameters
def create_random_polymers(box, polymers, separation, seed=1): util.print_status_line() # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf() # check if initialization has already occured if is_initialized(): globals.msg.error("Cannot initialize more than once\n") raise RuntimeError("Error creating random polymers") if type(polymers) != type([]) or len(polymers) == 0: globals.msg.error( "Polymers specified incorrectly. See the hoomd_script documentation\n" ) raise RuntimeError("Error creating random polymers") if type(separation) != type(dict()) or len(separation) == 0: globals.msg.error( "Polymers specified incorrectly. See the hoomd_script documentation\n" ) raise RuntimeError("Error creating random polymers") if not isinstance(box, data.boxdim): globals.msg.error('Box must be a data.boxdim object\n') raise TypeError('box must be a data.boxdim object') # create the generator generator = hoomd.RandomGenerator(my_exec_conf, box._getBoxDim(), seed, box.dimensions) # make a list of types used for an eventual check vs the types in separation for completeness types_used = [] # track the minimum bond length min_bond_len = None # build the polymer generators for poly in polymers: type_list = [] # check that all fields are specified if not 'bond_len' in poly: globals.msg.error('Polymer specification missing bond_len\n') raise RuntimeError("Error creating random polymers") if min_bond_len is None: min_bond_len = poly['bond_len'] else: min_bond_len = min(min_bond_len, poly['bond_len']) if not 'type' in poly: globals.msg.error('Polymer specification missing type\n') raise RuntimeError("Error creating random polymers") if not 'count' in poly: globals.msg.error('Polymer specification missing count\n') raise RuntimeError("Error creating random polymers") if not 'bond' in poly: globals.msg.error('Polymer specification missing bond\n') raise RuntimeError("Error creating random polymers") # build type list type_vector = hoomd.std_vector_string() for t in poly['type']: type_vector.append(t) if not t in types_used: types_used.append(t) # build bond list bond_a = hoomd.std_vector_uint() bond_b = hoomd.std_vector_uint() bond_name = hoomd.std_vector_string() # if the bond setting is 'linear' create a default set of bonds if poly['bond'] == 'linear': for i in range(0, len(poly['type']) - 1): bond_a.push_back(i) bond_b.push_back(i + 1) bond_name.append('polymer') #if it is a list, parse the user custom bonds elif type(poly['bond']) == type([]): for t in poly['bond']: # a 2-tuple gets the default 'polymer' name for the bond if len(t) == 2: a, b = t name = 'polymer' # and a 3-tuple specifies the name directly elif len(t) == 3: a, b, name = t else: globals.msg.error( 'Custom bond ' + str(t) + ' must have either two or three elements\n') raise RuntimeError("Error creating random polymers") bond_a.push_back(a) bond_b.push_back(b) bond_name.append(name) else: globals.msg.error('Unexpected argument value for polymer bond\n') raise RuntimeError("Error creating random polymers") # create the generator generator.addGenerator( int(poly['count']), hoomd.PolymerParticleGenerator(my_exec_conf, poly['bond_len'], type_vector, bond_a, bond_b, bond_name, 100, box.dimensions)) # check that all used types are in the separation list for t in types_used: if not t in separation: globals.msg.error("No separation radius specified for type " + str(t) + "\n") raise RuntimeError("Error creating random polymers") # set the separation radii, checking that it is within the minimum bond length for t, r in separation.items(): generator.setSeparationRadius(t, r) if 2 * r >= min_bond_len: globals.msg.error("Separation radius " + str(r) + " is too big for the minimum bond length of " + str(min_bond_len) + " specified\n") raise RuntimeError("Error creating random polymers") # generate the particles generator.generate() # copy over data to snapshot snapshot = generator.getSnapshot() my_domain_decomposition = _create_domain_decomposition(snapshot.global_box) if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf, my_domain_decomposition) else: globals.system_definition = hoomd.SystemDefinition( snapshot, my_exec_conf) # initialize the system globals.system = hoomd.System(globals.system_definition, 0) _perform_common_init_tasks() return data.system_data(globals.system_definition)
def create_random_polymers(box, polymers, separation, seed=1): util.print_status_line(); # initialize GPU/CPU execution configuration and MPI early my_exec_conf = _create_exec_conf(); # check if initialization has already occured if is_initialized(): globals.msg.error("Cannot initialize more than once\n"); raise RuntimeError("Error creating random polymers"); if type(polymers) != type([]) or len(polymers) == 0: globals.msg.error("polymers specified incorrectly. See the hoomd_script documentation\n"); raise RuntimeError("Error creating random polymers"); if type(separation) != type(dict()) or len(separation) == 0: globals.msg.error("polymers specified incorrectly. See the hoomd_script documentation\n"); raise RuntimeError("Error creating random polymers"); # create the generator generator = hoomd.RandomGenerator(my_exec_conf,box, seed); # make a list of types used for an eventual check vs the types in separation for completeness types_used = []; # track the minimum bond length min_bond_len = None; # build the polymer generators for poly in polymers: type_list = []; # check that all fields are specified if not 'bond_len' in poly: globals.msg.error('Polymer specification missing bond_len\n'); raise RuntimeError("Error creating random polymers"); if min_bond_len is None: min_bond_len = poly['bond_len']; else: min_bond_len = min(min_bond_len, poly['bond_len']); if not 'type' in poly: globals.msg.error('Polymer specification missing type\n'); raise RuntimeError("Error creating random polymers"); if not 'count' in poly: globals.msg.error('Polymer specification missing count\n'); raise RuntimeError("Error creating random polymers"); if not 'bond' in poly: globals.msg.error('Polymer specification missing bond\n'); raise RuntimeError("Error creating random polymers"); # build type list type_vector = hoomd.std_vector_string(); for t in poly['type']: type_vector.append(t); if not t in types_used: types_used.append(t); # build bond list bond_a = hoomd.std_vector_uint(); bond_b = hoomd.std_vector_uint(); bond_name = hoomd.std_vector_string(); # if the bond setting is 'linear' create a default set of bonds if poly['bond'] == 'linear': for i in range(0,len(poly['type'])-1): bond_a.push_back(i); bond_b.push_back(i+1); bond_name.append('polymer') #if it is a list, parse the user custom bonds elif type(poly['bond']) == type([]): for t in poly['bond']: # a 2-tuple gets the default 'polymer' name for the bond if len(t) == 2: a,b = t; name = 'polymer'; # and a 3-tuple specifies the name directly elif len(t) == 3: a,b,name = t; else: globals.msg.error('Custom bond ' + str(t) + ' must have either two or three elements\n'); raise RuntimeError("Error creating random polymers"); bond_a.push_back(a); bond_b.push_back(b); bond_name.append(name); else: globals.msg.error('Unexpected argument value for polymer bond\n'); raise RuntimeError("Error creating random polymers"); # create the generator generator.addGenerator(int(poly['count']), hoomd.PolymerParticleGenerator(my_exec_conf, poly['bond_len'], type_vector, bond_a, bond_b, bond_name, 100)); # check that all used types are in the separation list for t in types_used: if not t in separation: globals.msg.error("No separation radius specified for type " + str(t) + "\n"); raise RuntimeError("Error creating random polymers"); # set the separation radii, checking that it is within the minimum bond length for t,r in separation.items(): generator.setSeparationRadius(t, r); if 2*r >= min_bond_len: globals.msg.error("Separation radius " + str(r) + " is too big for the minimum bond length of " + str(min_bond_len) + " specified\n"); raise RuntimeError("Error creating random polymers"); # generate the particles generator.generate(); # copy over data to snapshot snapshot = generator.getSnapshot() my_domain_decomposition = _create_domain_decomposition(snapshot.global_box); if my_domain_decomposition is not None: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf, my_domain_decomposition); else: globals.system_definition = hoomd.SystemDefinition(snapshot, my_exec_conf); # initialize the system globals.system = hoomd.System(globals.system_definition, 0); _perform_common_init_tasks(); return data.system_data(globals.system_definition);