def __init__(self):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a variant before initialization\n");
raise RuntimeError('Error creating variant');
self.cpp_variant = None;
def tags(tag_min, tag_max=None, name=None):
util.print_status_line();
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n");
raise RuntimeError('Error creating group');
# handle the optional argument
if tag_max is not None:
if name is None:
name = 'tags ' + str(tag_min) + '-' + str(tag_max);
else:
# if the option is not specified, tag_max is set equal to tag_min to include only that particle in the range
# and the name is chosen accordingly
tag_max = tag_min;
if name is None:
name = 'tag ' + str(tag_min);
# create the group
selector = hoomd.ParticleSelectorTag(globals.system_definition, tag_min, tag_max);
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector);
# notify the user of the created group
globals.msg.notice(2, 'Group "' + name + '" created containing ' + str(cpp_group.getNumMembersGlobal()) + ' particles\n');
# return it in the wrapper class
return group(name, cpp_group);
def all():
util.print_status_line()
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n")
raise RuntimeError('Error creating group')
name = 'all'
# the all group is special: when the first one is created, it is cached in globals and future calls to group.all()
# return the cached version
if globals.group_all is not None:
expected_N = globals.system_definition.getParticleData().getNGlobal()
if len(globals.group_all) != expected_N:
globals.msg.error(
"globals.group_all does not appear to be the group of all particles!\n"
)
raise RuntimeError('Error creating group')
return globals.group_all
# create the group
selector = hoomd.ParticleSelectorAll(globals.system_definition)
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector, True)
# notify the user of the created group
globals.msg.notice(
2, 'Group "' + name + '" created containing ' +
str(cpp_group.getNumMembersGlobal()) + ' particles\n')
# cache it and then return it in the wrapper class
globals.group_all = group(name, cpp_group)
return globals.group_all
def all():
util.print_status_line();
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n");
raise RuntimeError('Error creating group');
# the all group is special: when the first one is created, it is cached in globals and future calls to group.all()
# return the cached version
if globals.group_all is not None:
expected_N = globals.system_definition.getParticleData().getNGlobal();
if len(globals.group_all) != expected_N:
globals.msg.error("globals.group_all does not appear to be the group of all particles!\n");
raise RuntimeError('Error creating group');
return globals.group_all;
# choose the tag range
tag_min = 0;
tag_max = globals.system_definition.getParticleData().getNGlobal()-1;
# create the group
name = 'all';
selector = hoomd.ParticleSelectorTag(globals.system_definition, tag_min, tag_max);
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector);
# notify the user of the created group
globals.msg.notice(2, 'Group "' + name + '" created containing ' + str(cpp_group.getNumMembersGlobal()) + ' particles\n');
# cache it and then return it in the wrapper class
globals.group_all = group(name, cpp_group);
return globals.group_all;
def r_buff(warmup=200000, r_min=0.05, r_max=1.0, jumps=20, steps=5000, set_max_check_period=False):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot tune r_buff before initialization\n");
# check that there is a nlist
if globals.neighbor_list is None:
globals.msg.error("Cannot tune r_buff when there is no neighbor list\n");
# start off at a check_period of 1
globals.neighbor_list.set_params(check_period=1);
# make the warmup run
hoomd_script.run(warmup);
# initialize scan variables
dr = (r_max - r_min) / (jumps - 1);
r_buff_list = [];
tps_list = [];
# loop over all desired r_buff points
for i in range(0,jumps):
# set the current r_buff
r_buff = r_min + i * dr;
globals.neighbor_list.set_params(r_buff=r_buff);
# run the benchmark 3 times
tps = [];
hoomd_script.run(steps);
tps.append(globals.system.getLastTPS())
hoomd_script.run(steps);
tps.append(globals.system.getLastTPS())
hoomd_script.run(steps);
tps.append(globals.system.getLastTPS())
# record the median tps of the 3
tps.sort();
tps_list.append(tps[1]);
r_buff_list.append(r_buff);
# find the fastest r_buff
fastest = tps_list.index(max(tps_list));
fastest_r_buff = r_buff_list[fastest];
# set the fastest and rerun the warmup steps to identify the max check period
globals.neighbor_list.set_params(r_buff=fastest_r_buff);
hoomd_script.run(warmup);
# notify the user of the benchmark results
globals.msg.notice(2, "r_buff = " + str(r_buff_list) + '\n');
globals.msg.notice(2, "tps = " + str(tps_list) + '\n');
globals.msg.notice(2, "Optimal r_buff: " + str(fastest_r_buff) + '\n');
globals.msg.notice(2, "Maximum check_period: " + str(globals.neighbor_list.query_update_period()) + '\n');
# set the found max check period
if set_max_check_period:
globals.neighbor_list.set_params(check_period=globals.neighbor_list.query_update_period());
# return the results to the script
return (fastest_r_buff, globals.neighbor_list.query_update_period());
def __init__(self, name=None):
# check if initialization has occured
if not init.is_initialized():
globals.msg.error("Cannot create force before initialization\n");
raise RuntimeError('Error creating force');
# Allow force to store a name. Used for discombobulation in the logger
if name is None:
self.name = "";
else:
self.name="_" + name;
self.cpp_force = None;
# increment the id counter
id = _force.cur_id;
_force.cur_id += 1;
self.force_name = "force%d" % (id);
self.enabled = True;
self.log =True;
globals.forces.append(self);
# base class constructor
meta._metadata.__init__(self)
def tags(tag_min, tag_max=None, name=None):
util.print_status_line()
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n")
raise RuntimeError('Error creating group')
# handle the optional argument
if tag_max is not None:
if name is None:
name = 'tags ' + str(tag_min) + '-' + str(tag_max)
else:
# if the option is not specified, tag_max is set equal to tag_min to include only that particle in the range
# and the name is chosen accordingly
tag_max = tag_min
if name is None:
name = 'tag ' + str(tag_min)
# create the group
selector = hoomd.ParticleSelectorTag(globals.system_definition, tag_min,
tag_max)
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector)
# notify the user of the created group
globals.msg.notice(
2, 'Group "' + name + '" created containing ' +
str(cpp_group.getNumMembersGlobal()) + ' particles\n')
# return it in the wrapper class
return group(name, cpp_group)
def verify(self, required_coeffs):
# first, check that the system has been initialized
if not init.is_initialized():
globals.msg.error("Cannot verify force coefficients before initialization\n");
raise RuntimeError('Error verifying force coefficients');
# get a list of types from the particle data
ntypes = globals.system_definition.getParticleData().getNTypes();
type_list = [];
for i in range(0,ntypes):
type_list.append(globals.system_definition.getParticleData().getNameByType(i));
valid = True;
# loop over all possible types and verify that all required variables are set
for i in range(0,ntypes):
type = type_list[i];
if type not in self.values.keys() and len(required_coeffs):
globals.msg.error("Particle type " + type + " is missing required coefficients\n");
return False
# verify that all required values are set by counting the matches
count = 0;
for coeff_name in self.values[type].keys():
if not coeff_name in required_coeffs:
globals.msg.notice(3, "Possible typo? Force coeff " + str(coeff_name) + " is specified for type " + str(type) +\
", but is not used by the external force");
else:
count += 1;
if count != len(required_coeffs):
globals.msg.error("Particle type " + type + " is missing required coefficients\n");
valid = False;
return valid;
def get_step():
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot get step before initialization\n");
raise RuntimeError('Error getting step');
return globals.system.getCurrentTimeStep();
def verify(self, required_coeffs):
# first, check that the system has been initialized
if not init.is_initialized():
globals.msg.error("Cannot verify force coefficients before initialization\n");
raise RuntimeError('Error verifying force coefficients');
# get a list of types from the particle data
ntypes = globals.system_definition.getParticleData().getNTypes();
type_list = [];
for i in range(0,ntypes):
type_list.append(globals.system_definition.getParticleData().getNameByType(i));
valid = True;
# loop over all possible types and verify that all required variables are set
for i in range(0,ntypes):
type = type_list[i];
if type not in self.values.keys() and len(required_coeffs):
globals.msg.error("Particle type " + type + " is missing required coefficients\n");
return False
# verify that all required values are set by counting the matches
count = 0;
for coeff_name in self.values[type].keys():
if not coeff_name in required_coeffs:
globals.msg.notice(3, "Possible typo? Force coeff " + str(coeff_name) + " is specified for type " + str(type) +\
", but is not used by the external force");
else:
count += 1;
if count != len(required_coeffs):
globals.msg.error("Particle type " + type + " is missing required coefficients\n");
valid = False;
return valid;
def type(type, name=None):
util.print_status_line();
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n");
raise RuntimeError('Error creating group');
if name is None:
name = 'type ' + type;
# get a list of types from the particle data
ntypes = globals.system_definition.getParticleData().getNTypes();
type_list = [];
for i in range(0,ntypes):
type_list.append(globals.system_definition.getParticleData().getNameByType(i));
if type not in type_list:
globals.msg.warning(str(type) + " does not exist in the system, creating an empty group\n");
cpp_list = hoomd.std_vector_uint();
cpp_group = hoomd.ParticleGroup(globals.system_definition, cpp_list);
else:
type_id = globals.system_definition.getParticleData().getTypeByName(type);
selector = hoomd.ParticleSelectorType(globals.system_definition, type_id, type_id);
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector);
# notify the user of the created group
globals.msg.notice(2, 'Group "' + name + '" created containing ' + str(cpp_group.getNumMembersGlobal()) + ' particles\n');
# return it in the wrapper class
return group(name, cpp_group);
def __init__(self, name=None):
# check if initialization has occured
if not init.is_initialized():
globals.msg.error("Cannot create force before initialization\n")
raise RuntimeError('Error creating force')
# Allow force to store a name. Used for discombobulation in the logger
if name is None:
self.name = ""
else:
self.name = "_" + name
self.cpp_force = None
# increment the id counter
id = _force.cur_id
_force.cur_id += 1
self.force_name = "force%d" % (id)
self.enabled = True
self.log = True
globals.forces.append(self)
# base class constructor
meta._metadata.__init__(self)
def get_step():
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot get step before initialization\n")
raise RuntimeError('Error getting step')
return globals.system.getCurrentTimeStep()
def get_rank():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getRank()
else:
return hoomd.ExecutionConfiguration.guessRank(globals.msg)
else:
return 0
def get_rank():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getRank()
else:
return hoomd.ExecutionConfiguration.guessRank(globals.msg)
else:
return 0;
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 set_mode(mode):
if init.is_initialized():
globals.msg.error("Cannot change mode after initialization\n");
raise RuntimeError('Error setting option');
if mode is not None:
if not (mode == "cpu" or mode == "gpu"):
globals.msg.error("Invalid mode setting\n");
raise RuntimeError('Error setting option');
globals.options.mode = mode;
def set_mode(mode):
if init.is_initialized():
globals.msg.error("Cannot change mode after initialization\n");
raise RuntimeError('Error setting option');
if mode is not None:
if not (mode == "cpu" or mode == "gpu"):
globals.msg.error("Invalid mode setting\n");
raise RuntimeError('Error setting option');
globals.options.mode = mode;
def get_num_ranks():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getNRanks();
else:
if globals.options.nrank is not None:
return globals.options.nrank;
else:
return hoomd.ExecutionConfiguration.getNRanksGlobal()
else:
return 1;
def get_num_ranks():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getNRanks()
else:
if globals.options.nrank is not None:
return globals.options.nrank
else:
return hoomd.ExecutionConfiguration.getNRanksGlobal()
else:
return 1
def get_partition():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getPartition()
else:
if globals.options.nrank is not None:
return int(hoomd.ExecutionConfiguration.guessRank(globals.msg)/globals.options.nrank)
else:
return 0
else:
return 0;
def get_rank():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getRank()
else:
if globals.options.nrank is not None:
# recompute local rank
return int(hoomd.ExecutionConfiguration.getRankGlobal() % globals.options.nrank)
else:
return hoomd.ExecutionConfiguration.getRankGlobal()
else:
return 0;
def get_partition():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getPartition()
else:
if globals.options.nrank is not None:
# re-compute partition number
return int(hoomd.ExecutionConfiguration.getRankGlobal()/globals.options.nrank)
else:
return 0
else:
return 0;
def get_partition():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getPartition()
else:
if globals.options.nrank is not None:
return int(
hoomd.ExecutionConfiguration.guessRank(globals.msg) /
globals.options.nrank)
else:
return 0
else:
return 0
def get_partition():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getPartition()
else:
if globals.options.nrank is not None:
# re-compute partition number
return int(hoomd.ExecutionConfiguration.getRankGlobal() /
globals.options.nrank)
else:
return 0
else:
return 0
def get_rank():
if hoomd.is_MPI_available():
if init.is_initialized():
return globals.exec_conf.getRank()
else:
if globals.options.nrank is not None:
# recompute local rank
return int(hoomd.ExecutionConfiguration.getRankGlobal() %
globals.options.nrank)
else:
return hoomd.ExecutionConfiguration.getRankGlobal()
else:
return 0
def __init__(self):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create updater before initialization\n");
raise RuntimeError('Error creating updater');
self.cpp_updater = None;
# increment the id counter
id = _updater.cur_id;
_updater.cur_id += 1;
self.updater_name = "updater%d" % (id);
self.enabled = True;
def __init__(self):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create analyzer before initialization\n")
raise RuntimeError("Error creating analyzer")
self.cpp_analyzer = None
# increment the id counter
id = _analyzer.cur_id
_analyzer.cur_id += 1
self.analyzer_name = "analyzer%d" % (id)
self.enabled = True
def __init__(self):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create analyzer before initialization\n")
raise RuntimeError('Error creating analyzer')
self.cpp_analyzer = None
# increment the id counter
id = _analyzer.cur_id
_analyzer.cur_id += 1
self.analyzer_name = "analyzer%d" % (id)
self.enabled = True
def __init__(self):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create compute before initialization\n");
raise RuntimeError('Error creating compute');
self.cpp_compute = None;
# increment the id counter
id = _compute.cur_id;
_compute.cur_id += 1;
self.compute_name = "compute%d" % (id);
self.enabled = True;
def __init__(self):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create compute before initialization\n")
raise RuntimeError('Error creating compute')
self.cpp_compute = None
# increment the id counter
id = _compute.cur_id
_compute.cur_id += 1
self.compute_name = "compute%d" % (id)
self.enabled = True
def cuboid(name,
xmin=None,
xmax=None,
ymin=None,
ymax=None,
zmin=None,
zmax=None):
util.print_status_line()
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n")
raise RuntimeError('Error creating group')
# handle the optional arguments
box = globals.system_definition.getParticleData().getBox()
if xmin is None:
xmin = box.getLo().x - 0.5
if xmax is None:
xmax = box.getHi().x + 0.5
if ymin is None:
ymin = box.getLo().y - 0.5
if ymax is None:
ymax = box.getHi().y + 0.5
if zmin is None:
zmin = box.getLo().z - 0.5
if zmax is None:
zmax = box.getHi().z + 0.5
ll = hoomd.Scalar3()
ur = hoomd.Scalar3()
ll.x = float(xmin)
ll.y = float(ymin)
ll.z = float(zmin)
ur.x = float(xmax)
ur.y = float(ymax)
ur.z = float(zmax)
# create the group
selector = hoomd.ParticleSelectorCuboid(globals.system_definition, ll, ur)
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector)
# notify the user of the created group
globals.msg.notice(
2, 'Group "' + name + '" created containing ' +
str(cpp_group.getNumMembersGlobal()) + ' particles\n')
# return it in the wrapper class
return group(name, cpp_group)
def series(warmup=100000, repeat=20, steps=10000, limit_hours=None):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot tune r_buff before initialization\n");
tps_list = [];
if warmup > 0:
hoomd_script.run(warmup);
for i in range(0,repeat):
hoomd_script.run(steps, limit_hours=limit_hours);
tps_list.append(globals.system.getLastTPS());
return tps_list;
def series(warmup=100000, repeat=20, steps=10000, limit_hours=None):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot tune r_buff before initialization\n");
tps_list = [];
if warmup > 0:
hoomd_script.run(warmup);
for i in range(0,repeat):
hoomd_script.run(steps, limit_hours=limit_hours);
tps_list.append(globals.system.getLastTPS());
return tps_list;
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 __init__(self):
# check if initialization has occured
if not init.is_initialized():
globals.msg.error("Cannot create neighbor list before initialization\n");
raise RuntimeError('Error creating neighbor list');
# default exclusions
self.is_exclusion_overridden = False;
self.exclusions = None
# save the parameters we set
self.r_cut = rcut();
self.r_buff = 0.0;
# save a list of subscribers that may have a say in determining the maximum r_cut
self.subscriber_callbacks = [];
def set_ncpu(ncpu):
if init.is_initialized():
globals.msg.error("Cannot change number of threads after initialization\n");
raise RuntimeError('Error setting option');
if ncpu is not None:
try:
ncpu = int(ncpu);
except ValueError:
globals.msg.error("ncpu must be an integer\n");
raise RuntimeError('Error setting option');
# imply mode=cpu
globals.options.mode = "cpu";
globals.options.ncpu = ncpu;
def set_gpu(gpu):
if init.is_initialized():
globals.msg.error("Cannot change gpu after initialization\n");
raise RuntimeError('Error setting option');
if gpu is not None:
try:
gpu = int(gpu);
except ValueError:
globals.msg.error("gpu must be an integer\n");
raise RuntimeError('Error setting option');
# imply mode=gpu
globals.options.mode = "gpu";
globals.options.gpu = gpu;
def set_ncpu(ncpu):
if init.is_initialized():
globals.msg.error("Cannot change number of threads after initialization\n");
raise RuntimeError('Error setting option');
if ncpu is not None:
try:
ncpu = int(ncpu);
except ValueError:
globals.msg.error("ncpu must be an integer\n");
raise RuntimeError('Error setting option');
# imply mode=cpu
globals.options.mode = "cpu";
globals.options.ncpu = ncpu;
def set_gpu(gpu):
if init.is_initialized():
globals.msg.error("Cannot change gpu after initialization\n");
raise RuntimeError('Error setting option');
if gpu is not None:
try:
gpu = int(gpu);
except ValueError:
globals.msg.error("gpu must be an integer\n");
raise RuntimeError('Error setting option');
# imply mode=gpu
globals.options.mode = "gpu";
globals.options.gpu = gpu;
def rigid():
util.print_status_line();
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n");
raise RuntimeError('Error creating group');
# create the group
name = 'rigid';
selector = hoomd.ParticleSelectorRigid(globals.system_definition, True);
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector);
# notify the user of the created group
globals.msg.notice(2, 'Group "' + name + '" created containing ' + str(cpp_group.getNumMembersGlobal()) + ' particles\n');
# return it in the wrapper class
return group(name, cpp_group);
def series(warmup=100000, repeat=20, steps=10000):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot tune r_buff before initialization\n");
tps_list = [];
hoomd_script.run(warmup);
for i in range(0,repeat):
hoomd_script.run(steps);
tps_list.append(globals.system.getLastTPS());
if numpy is not None:
globals.msg.notice(1, "**Notice: Series average TPS: %4.2f\n" % numpy.average(tps_list));
globals.msg.notice(1, " Series median TPS : %4.2f\n" % numpy.median(tps_list));
globals.msg.notice(1, " Series TPS std dev: %4.2f" % numpy.std(tps_list));
return tps_list;
def __init__(self):
# check if initialization has occured
if not init.is_initialized():
globals.msg.error("Cannot create force before initialization\n")
raise RuntimeError('Error creating constraint force')
self.cpp_force = None
# increment the id counter
id = _constraint_force.cur_id
_constraint_force.cur_id += 1
self.force_name = "constraint_force%d" % (id)
self.enabled = True
globals.constraint_forces.append(self)
# create force data iterator
self.forces = data.force_data(self)
def __init__(self):
# check if initialization has occured
if not init.is_initialized():
globals.msg.error("Cannot create force before initialization\n");
raise RuntimeError('Error creating constraint force');
self.cpp_force = None;
# increment the id counter
id = _constraint_force.cur_id;
_constraint_force.cur_id += 1;
self.force_name = "constraint_force%d" % (id);
self.enabled = True;
globals.constraint_forces.append(self);
# create force data iterator
self.forces = data.force_data(self);
def verify(self, required_coeffs):
# first, check that the system has been initialized
if not init.is_initialized():
globals.msg.error("Cannot verify bond coefficients before initialization\n")
raise RuntimeError("Error verifying force coefficients")
# get a list of types from the particle data
ntypes = globals.system_definition.getBondData().getNTypes()
type_list = []
for i in range(0, ntypes):
type_list.append(globals.system_definition.getBondData().getNameByType(i))
valid = True
# loop over all possible types and verify that all required variables are set
for i in range(0, ntypes):
type = type_list[i]
if type not in self.values.keys():
globals.msg.error("Bond type " + str(type) + " not found in bond coeff\n")
valid = False
continue
# verify that all required values are set by counting the matches
count = 0
for coeff_name in self.values[type].keys():
if not coeff_name in required_coeffs:
globals.msg.notice(
2,
"Notice: Possible typo? Force coeff "
+ str(coeff_name)
+ " is specified for type "
+ str(type)
+ ", but is not used by the bond force\n",
)
else:
count += 1
if count != len(required_coeffs):
globals.msg.error("Bond type " + str(type) + " is missing required coefficients\n")
valid = False
return valid
def __init__(self):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create updater before initialization\n");
raise RuntimeError('Error creating updater');
self.cpp_updater = None;
# increment the id counter
id = _updater.cur_id;
_updater.cur_id += 1;
self.updater_name = "updater%d" % (id);
self.enabled = True;
# Store a reference in global simulation variables
globals.updaters.append(self)
# base class constructor
meta._metadata.__init__(self)
def rigid():
util.print_status_line()
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n")
raise RuntimeError('Error creating group')
# create the group
name = 'rigid'
selector = hoomd.ParticleSelectorRigid(globals.system_definition, True)
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector)
# notify the user of the created group
globals.msg.notice(
2, 'Group "' + name + '" created containing ' +
str(cpp_group.getNumMembersGlobal()) + ' particles\n')
# return it in the wrapper class
return group(name, cpp_group)
def __init__(self):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create analyzer before initialization\n");
raise RuntimeError('Error creating analyzer');
self.cpp_analyzer = None;
# increment the id counter
id = _analyzer.cur_id;
_analyzer.cur_id += 1;
self.analyzer_name = "analyzer%d" % (id);
self.enabled = True;
# Store a reference in global simulation variables
globals.analyzers.append(self)
# base class constructor
meta._metadata.__init__(self)
def fill(self):
# first, check that the system has been initialized
if not init.is_initialized():
globals.msg.error("Cannot fill rcut(i,j) before initialization\n");
raise RuntimeError('Error filling nlist rcut(i,j)');
# get a list of types from the particle data
ntypes = globals.system_definition.getParticleData().getNTypes();
type_list = [];
for i in range(0,ntypes):
type_list.append(globals.system_definition.getParticleData().getNameByType(i));
# loop over all possible pairs and require that a dictionary key exists for them
for i in range(0,ntypes):
for j in range(i,ntypes):
a = type_list[i];
b = type_list[j];
# ensure the pair
cur_pair = self.ensure_pair(a,b);
def cuboid(name, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):
util.print_status_line();
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n");
raise RuntimeError('Error creating group');
# handle the optional arguments
box = globals.system_definition.getParticleData().getBox();
if xmin is None:
xmin = box.getLo().x - 0.5;
if xmax is None:
xmax = box.getHi().x + 0.5;
if ymin is None:
ymin = box.getLo().y - 0.5;
if ymax is None:
ymax = box.getHi().y + 0.5;
if zmin is None:
zmin = box.getLo().z - 0.5;
if zmax is None:
zmax = box.getHi().z + 0.5;
ll = hoomd.Scalar3();
ur = hoomd.Scalar3();
ll.x = float(xmin);
ll.y = float(ymin);
ll.z = float(zmin);
ur.x = float(xmax);
ur.y = float(ymax);
ur.z = float(zmax);
# create the group
selector = hoomd.ParticleSelectorCuboid(globals.system_definition, ll, ur);
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector);
# notify the user of the created group
globals.msg.notice(2, 'Group "' + name + '" created containing ' + str(cpp_group.getNumMembersGlobal()) + ' particles\n');
# return it in the wrapper class
return group(name, cpp_group);
def tag_list(name, tags):
util.print_status_line();
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n");
raise RuntimeError('Error creating group');
# build a vector of the tags
cpp_list = hoomd.std_vector_uint();
for t in tags:
cpp_list.push_back(t);
# create the group
cpp_group = hoomd.ParticleGroup(globals.system_definition, cpp_list);
# notify the user of the created group
globals.msg.notice(2, 'Group "' + name + '" created containing ' + str(cpp_group.getNumMembersGlobal()) + ' particles\n');
# return it in the wrapper class
return group(name, cpp_group);
def verify(self, required_coeffs):
# first, check that the system has been initialized
if not init.is_initialized():
globals.msg.error(
"Cannot verify angle coefficients before initialization\n")
raise RuntimeError('Error verifying force coefficients')
# get a list of types from the particle data
ntypes = globals.system_definition.getAngleData().getNTypes()
type_list = []
for i in range(0, ntypes):
type_list.append(
globals.system_definition.getAngleData().getNameByType(i))
valid = True
# loop over all possible types and verify that all required variables are set
for i in range(0, ntypes):
type = type_list[i]
if type not in self.values.keys():
globals.msg.error("Angle type " + str(type) +
" not found in angle coeff\n")
valid = False
continue
# verify that all required values are set by counting the matches
count = 0
for coeff_name in self.values[type].keys():
if not coeff_name in required_coeffs:
globals.msg.notice(2, "Notice: Possible typo? Force coeff " + str(coeff_name) + " is specified for type " + str(type) + \
", but is not used by the angle force\n")
else:
count += 1
if count != len(required_coeffs):
globals.msg.error("Angle type " + str(type) +
" is missing required coefficients\n")
valid = False
return valid
def type(type, name=None, update=False):
util.print_status_line()
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n")
raise RuntimeError('Error creating group')
if name is None:
name = 'type ' + type
# get a list of types from the particle data
ntypes = globals.system_definition.getParticleData().getNTypes()
type_list = []
for i in range(0, ntypes):
type_list.append(
globals.system_definition.getParticleData().getNameByType(i))
if type not in type_list:
globals.msg.warning(
str(type) +
" does not exist in the system, creating an empty group\n")
cpp_list = hoomd.std_vector_uint()
cpp_group = hoomd.ParticleGroup(globals.system_definition, cpp_list)
else:
type_id = globals.system_definition.getParticleData().getTypeByName(
type)
selector = hoomd.ParticleSelectorType(globals.system_definition,
type_id, type_id)
cpp_group = hoomd.ParticleGroup(globals.system_definition, selector,
update)
# notify the user of the created group
globals.msg.notice(
2, 'Group "' + name + '" created containing ' +
str(cpp_group.getNumMembersGlobal()) + ' particles\n')
# return it in the wrapper class
return group(name, cpp_group)
def charged(name='charged'):
util.print_status_line()
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n")
raise RuntimeError('Error creating group')
util._disable_status_lines = True
# determine the group of particles that are charged
charged_tags = []
sysdef = globals.system_definition
pdata = data.particle_data(sysdef.getParticleData())
for i in range(0, len(pdata)):
if pdata[i].charge != 0.0:
charged_tags.append(i)
retval = tag_list(name, charged_tags)
util._disable_status_lines = False
return retval
def tag_list(name, tags):
util.print_status_line()
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot create a group before initialization\n")
raise RuntimeError('Error creating group')
# build a vector of the tags
cpp_list = hoomd.std_vector_uint()
for t in tags:
cpp_list.push_back(t)
# create the group
cpp_group = hoomd.ParticleGroup(globals.system_definition, cpp_list)
# notify the user of the created group
globals.msg.notice(
2, 'Group "' + name + '" created containing ' +
str(cpp_group.getNumMembersGlobal()) + ' particles\n')
# return it in the wrapper class
return group(name, cpp_group)
def series(warmup=100000, repeat=20, steps=10000):
# check if initialization has occurred
if not init.is_initialized():
globals.msg.error("Cannot tune r_buff before initialization\n")
tps_list = []
hoomd_script.run(warmup)
for i in range(0, repeat):
hoomd_script.run(steps)
tps_list.append(globals.system.getLastTPS())
if numpy is not None:
globals.msg.notice(
1,
"**Notice: Series average TPS: %4.2f\n" % numpy.average(tps_list))
globals.msg.notice(
1,
" Series median TPS : %4.2f\n" % numpy.median(tps_list))
globals.msg.notice(
1, " Series TPS std dev: %4.2f" % numpy.std(tps_list))
return tps_list
def run_upto(step, **keywords):
if 'quiet' in keywords and not keywords['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')
# determine the number of steps to run
step = int(step)
cur_step = globals.system.getCurrentTimeStep()
if cur_step >= step:
globals.msg.warning(
"Requesting run up to a time step that has already passed, doing nothing\n"
)
return
n_steps = step - cur_step
_util._disable_status_lines = True
run(n_steps, **keywords)
_util._disable_status_lines = False
