def _perform_common_init_tasks():
from hoomd_script import update
from hoomd_script import group
from hoomd_script import compute
# create the sorter
globals.sorter = update.sort()
# create the default compute.thermo on the all group
util._disable_status_lines = True
all = group.all()
compute._get_unique_thermo(group=all)
util._disable_status_lines = False
# set up Communicator, and register it with the System
if hoomd.is_MPI_available():
cpp_decomposition = globals.system_definition.getParticleData().getDomainDecomposition()
if cpp_decomposition is not None:
# create the c++ Communicator
if not globals.exec_conf.isCUDAEnabled():
cpp_communicator = hoomd.Communicator(globals.system_definition, cpp_decomposition)
else:
cpp_communicator = hoomd.CommunicatorGPU(globals.system_definition, cpp_decomposition)
# set Communicator in C++ System
globals.system.setCommunicator(cpp_communicator)
def __init__(self, group, P, r):
util.print_status_line()
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData(
).getDomainDecomposition():
globals.msg.error(
"constrain.sphere is not supported in multi-processor simulations.\n\n"
)
raise RuntimeError("Error initializing constraint force.")
# 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 globals.exec_conf.isCUDAEnabled():
self.cpp_force = hoomd.ConstraintSphere(globals.system_definition,
group.cpp_group, P, r)
else:
self.cpp_force = hoomd.ConstraintSphereGPU(
globals.system_definition, group.cpp_group, P, r)
globals.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 _perform_common_init_tasks():
from hoomd_script import update;
from hoomd_script import group;
from hoomd_script import compute;
# create the sorter, using the evil import __main__ trick to provide the user with a default variable
import __main__;
__main__.sorter = update.sort();
# create the default compute.thermo on the all group
util._disable_status_lines = True;
all = group.all();
compute._get_unique_thermo(group=all);
util._disable_status_lines = False;
# set up Communicator, and register it with the System
if hoomd.is_MPI_available():
cpp_decomposition = globals.system_definition.getParticleData().getDomainDecomposition();
if cpp_decomposition is not None:
# create the c++ Communicator
if not globals.exec_conf.isCUDAEnabled():
cpp_communicator = hoomd.Communicator(globals.system_definition, cpp_decomposition)
else:
cpp_communicator = hoomd.CommunicatorGPU(globals.system_definition, cpp_decomposition)
# set Communicator in C++ System
globals.system.setCommunicator(cpp_communicator)
def _create_domain_decomposition(box):
if not hoomd.is_MPI_available():
return None
# default values for arguents
nx = ny = nz = 0
linear = False
if globals.options.nx is not None:
nx = globals.options.nx
if globals.options.ny is not None:
ny = globals.options.ny
if globals.options.nz is not None:
nz = globals.options.nz
if globals.options.linear is not None:
linear = globals.options.linear
if linear is True:
# set up linear decomposition
nz = globals.exec_conf.getNRanks()
# if we are only running on one processor, we use optimized code paths
# for single-GPU execution
if globals.exec_conf.getNRanks() == 1:
return None
# initialize domain decomposition
return hoomd.DomainDecomposition(globals.exec_conf, box.getL(), nx, ny, nz);
def __init__(self, x=True, y=True, z=True, tolerance=1.02, maxiter=1, period=1000, phase=-1):
util.print_status_line();
# initialize base class
_updater.__init__(self);
# balancing cannot be done without mpi
if not hoomd.is_MPI_available():
globals.msg.warning("Ignoring balance command, not supported in current configuration.\n")
return
# create the c++ mirror class
if not globals.exec_conf.isCUDAEnabled():
self.cpp_updater = hoomd.LoadBalancer(globals.system_definition, globals.decomposition.cpp_dd);
else:
self.cpp_updater = hoomd.LoadBalancerGPU(globals.system_definition, globals.decomposition.cpp_dd);
self.setupUpdater(period,phase)
# stash arguments to metadata
self.metadata_fields = ['tolerance','maxiter','period','phase']
self.period = period
self.phase = phase
# configure the parameters
util._disable_status_lines = True
self.set_params(x,y,z,tolerance, maxiter)
util._disable_status_lines = False
def __init__(self, group):
util.print_status_line();
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData().getDomainDecomposition():
globals.msg.error("charge.pppm is not supported in multi-processor simulations.\n\n")
raise RuntimeError("Error initializing PPPM.")
# initialize the base class
force._force.__init__(self);
# create the c++ mirror class
# update the neighbor list
neighbor_list = pair._update_global_nlist(0.0)
neighbor_list.subscribe(lambda: self.log*0.0)
if not globals.exec_conf.isCUDAEnabled():
self.cpp_force = hoomd.PPPMForceCompute(globals.system_definition, neighbor_list.cpp_nlist, group.cpp_group);
else:
self.cpp_force = hoomd.PPPMForceComputeGPU(globals.system_definition, neighbor_list.cpp_nlist, group.cpp_group);
globals.system.addCompute(self.cpp_force, self.force_name);
# error check flag - must be set to true by set_params in order for the run() to commence
self.params_set = False;
# initialize the short range part of electrostatics
util._disable_status_lines = True;
self.ewald = pair.ewald(r_cut = 0.0);
util._disable_status_lines = False;
def _create_domain_decomposition(box):
if not hoomd.is_MPI_available():
return None
# default values for arguents
nx = ny = nz = 0
linear = False
if globals.options.nx is not None:
nx = globals.options.nx
if globals.options.ny is not None:
ny = globals.options.ny
if globals.options.nz is not None:
nz = globals.options.nz
if globals.options.linear is not None:
linear = globals.options.linear
if linear is True:
# set up linear decomposition
nz = globals.exec_conf.getNRanks()
# if we are only running on one processor, we use optimized code paths
# for single-GPU execution
if globals.exec_conf.getNRanks() == 1:
return None
# initialize domain decomposition
return hoomd.DomainDecomposition(globals.exec_conf, box.getL(), nx, ny, nz,
not globals.options.onelevel)
def get_partition():
hoomd_script.context._verify_init()
if hoomd.is_MPI_available():
return globals.exec_conf.getPartition()
else:
return 0
def get_partition():
hoomd_script.context._verify_init();
if hoomd.is_MPI_available():
return globals.exec_conf.getPartition()
else:
return 0;
def __init__(self, group):
util.print_status_line();
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData().getDomainDecomposition():
globals.msg.error("charge.pppm is not supported in multi-processor simulations.\n\n")
raise RuntimeError("Error initializing PPPM.")
# initialize the base class
force._force.__init__(self);
# create the c++ mirror class
# update the neighbor list
neighbor_list = pair._update_global_nlist(0.0)
neighbor_list.subscribe(lambda: self.log*0.0)
if not globals.exec_conf.isCUDAEnabled():
self.cpp_force = hoomd.PPPMForceCompute(globals.system_definition, neighbor_list.cpp_nlist, group.cpp_group);
else:
self.cpp_force = hoomd.PPPMForceComputeGPU(globals.system_definition, neighbor_list.cpp_nlist, group.cpp_group);
globals.system.addCompute(self.cpp_force, self.force_name);
# error check flag - must be set to true by set_params in order for the run() to commence
self.params_set = False;
# initialize the short range part of electrostatics
util._disable_status_lines = True;
self.ewald = pair.ewald(r_cut = 0.0);
util._disable_status_lines = False;
def __init__(self, filename="dump", period=None, phase=-1):
util.print_status_line();
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData().getDomainDecomposition():
globals.msg.error("dump.pdb is not supported in multi-processor simulations.\n\n")
raise RuntimeError("Error writing PDB file.")
# initialize base class
analyze._analyzer.__init__(self);
# create the c++ mirror class
self.cpp_analyzer = hoomd.PDBDumpWriter(globals.system_definition, filename);
if period is not None:
self.setupAnalyzer(period, phase);
self.enabled = True;
self.prev_period = 1;
elif filename != "dump":
util._disable_status_lines = True;
self.write(filename);
util._disable_status_lines = False;
else:
self.enabled = False;
def __init__(self, filename="dump", period=None, phase=-1):
util.print_status_line()
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData(
).getDomainDecomposition():
globals.msg.error(
"dump.pdb is not supported in multi-processor simulations.\n\n"
)
raise RuntimeError("Error writing PDB file.")
# initialize base class
analyze._analyzer.__init__(self)
# create the c++ mirror class
self.cpp_analyzer = hoomd.PDBDumpWriter(globals.system_definition,
filename)
if period is not None:
self.setupAnalyzer(period, phase)
self.enabled = True
self.prev_period = 1
elif filename != "dump":
util._disable_status_lines = True
self.write(filename)
util._disable_status_lines = False
else:
self.enabled = False
def __init__(self, group, P, r):
util.print_status_line();
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData().getDomainDecomposition():
globals.msg.error("constrain.sphere is not supported in multi-processor simulations.\n\n")
raise RuntimeError("Error initializing constraint force.")
# 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 globals.exec_conf.isCUDAEnabled():
self.cpp_force = hoomd.ConstraintSphere(globals.system_definition, group.cpp_group, P, r);
else:
self.cpp_force = hoomd.ConstraintSphereGPU(globals.system_definition, group.cpp_group, P, r);
globals.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 _perform_common_init_tasks():
from hoomd_script import update
from hoomd_script import group
from hoomd_script import compute
# create the sorter
globals.sorter = update.sort()
# create the default compute.thermo on the all group
util._disable_status_lines = True
all = group.all()
compute._get_unique_thermo(group=all)
util._disable_status_lines = False
# set up Communicator, and register it with the System
if hoomd.is_MPI_available():
cpp_decomposition = globals.system_definition.getParticleData(
).getDomainDecomposition()
if cpp_decomposition is not None:
# create the c++ Communicator
if not globals.exec_conf.isCUDAEnabled():
cpp_communicator = hoomd.Communicator(
globals.system_definition, cpp_decomposition)
else:
cpp_communicator = hoomd.CommunicatorGPU(
globals.system_definition, cpp_decomposition)
# set Communicator in C++ System
globals.system.setCommunicator(cpp_communicator)
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 __init__(self,
r=None,
rx=None,
ry=None,
rz=None,
P=hoomd.make_scalar3(0, 0, 0),
group=None):
util.print_status_line()
period = 1
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData(
).getDomainDecomposition():
globals.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):
globals.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 globals.exec_conf.isCUDAEnabled():
if (group is not None):
self.cpp_updater = hoomd.ConstraintEllipsoid(
globals.system_definition, group.cpp_group, P, rx, ry, rz)
else:
self.cpp_updater = hoomd.ConstraintEllipsoid(
globals.system_definition, globals.group_all.cpp_group, P,
rx, ry, rz)
else:
if (group is not None):
self.cpp_updater = hoomd.ConstraintEllipsoidGPU(
globals.system_definition, group.cpp_group, P, rx, ry, rz)
else:
self.cpp_updater = hoomd.ConstraintEllipsoidGPU(
globals.system_definition, globals.group_all.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,
filename="dump",
period=None,
file1=None,
file2=None,
compress=True):
util.print_status_line()
globals.msg.warning(
"dump.bin is deprecated and will be removed in the next release")
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData(
).getDomainDecomposition():
globals.msg.error(
"dump.bin is not supported in multi-processor simulations.\n\n"
)
raise RuntimeError("Error writing restart data.")
# initialize base class
analyze._analyzer.__init__(self)
# create the c++ mirror class
self.cpp_analyzer = hoomd.HOOMDBinaryDumpWriter(
globals.system_definition, filename)
self.cpp_analyzer.enableCompression(compress)
# handle the alternation setting
# first, check that they are both set
if (file1 is not None and file2 is None) or (file2 is not None
and file1 is None):
globals.msg.error(
"file1 and file2 must either both be set or both left as None.\n"
)
raise RuntimeError('Error initializing dump.bin')
if file1 is not None:
self.cpp_analyzer.setAlternatingWrites(file1, file2)
if period is None:
globals.msg.warning(
"Alternating file output set for dump.bin, but period is not set.\n"
)
globals.msg.warning("No output will be written.\n")
globals.msg.warning("dump.bin does not support triclinic boxes.\n")
globals.msg.warning(
"dump.bin is deprecated and will be replaced in v1.1.0\n")
if period is not None:
self.setupAnalyzer(period)
self.enabled = True
self.prev_period = 1
elif filename != "dump":
util._disable_status_lines = True
self.write(filename)
util._disable_status_lines = False
else:
self.enabled = False
def _create_exec_conf():
# use a cached execution configuration if available
if globals.exec_conf is not None:
return globals.exec_conf
mpi_available = hoomd.is_MPI_available();
# set the openmp thread limits
if globals.options.ncpu is not None:
if globals.options.ncpu > hoomd.get_num_procs():
globals.msg.warning("Requesting more CPU cores than there are available in the system\n");
hoomd.set_num_threads(globals.options.ncpu);
# if no command line options were specified, create a default ExecutionConfiguration
if globals.options.mode is None:
if mpi_available:
if globals.options.nrank is not None:
exec_conf = hoomd.ExecutionConfiguration(globals.options.min_cpu, globals.options.ignore_display, globals.msg, True, globals.options.nrank);
else:
exec_conf = hoomd.ExecutionConfiguration(globals.options.min_cpu, globals.options.ignore_display, globals.msg,True);
else:
exec_conf = hoomd.ExecutionConfiguration(globals.options.min_cpu, globals.options.ignore_display, globals.msg);
else:
# determine the GPU on which to execute
if globals.options.gpu is not None:
gpu_id = int(globals.options.gpu);
else:
gpu_id = -1;
# create the specified configuration
if globals.options.mode == "cpu":
if mpi_available:
if globals.options.nrank is not None:
exec_conf = hoomd.ExecutionConfiguration(hoomd.ExecutionConfiguration.executionMode.CPU, gpu_id, globals.options.min_cpu, globals.options.ignore_display, globals.msg, True, globals.options.nrank);
else:
exec_conf = hoomd.ExecutionConfiguration(hoomd.ExecutionConfiguration.executionMode.CPU, gpu_id, globals.options.min_cpu, globals.options.ignore_display, globals.msg, True);
else:
exec_conf = hoomd.ExecutionConfiguration(hoomd.ExecutionConfiguration.executionMode.CPU, gpu_id, globals.options.min_cpu, globals.options.ignore_display, globals.msg);
elif globals.options.mode == "gpu":
if mpi_available:
if globals.options.nrank is not None:
exec_conf = hoomd.ExecutionConfiguration(hoomd.ExecutionConfiguration.executionMode.GPU, gpu_id, globals.options.min_cpu, globals.options.ignore_display, globals.msg, True, globals.options.nrank);
else:
exec_conf = hoomd.ExecutionConfiguration(hoomd.ExecutionConfiguration.executionMode.GPU, gpu_id, globals.options.min_cpu, globals.options.ignore_display, globals.msg, True);
else:
exec_conf = hoomd.ExecutionConfiguration(hoomd.ExecutionConfiguration.executionMode.GPU, gpu_id, globals.options.min_cpu, globals.options.ignore_display, globals.msg);
else:
raise RuntimeError("Error initializing");
# if gpu_error_checking is set, enable it on the GPU
if globals.options.gpu_error_checking:
exec_conf.setCUDAErrorChecking(True);
globals.exec_conf = exec_conf;
return exec_conf;
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_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_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_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 _create_domain_decomposition(box):
if not hoomd.is_MPI_available():
return None
# if we are only running on one processor, we use optimized code paths
# for single-GPU execution
if globals.exec_conf.getNRanks() == 1:
return None
# okay, we want a decomposition but one isn't set, so make a default one
if globals.decomposition is None:
# this is happening transparently to the user, so hush this up
util._disable_status_lines = True
globals.decomposition = comm.decomposition()
util._disable_status_lines = False
return globals.decomposition._make_cpp_decomposition(box)
def _create_exec_conf():
# use a cached execution configuration if available
if globals.exec_conf is not None:
return globals.exec_conf
mpi_available = hoomd.is_MPI_available()
# error out on nyx/flux if the auto mode is set
if globals.options.mode == 'auto':
if (re.match("flux*", platform.node()) is not None) or (re.match(
"nyx*", platform.node()) is not None):
globals.msg.error(
"--mode=gpu or --mode=cpu must be specified on nyx/flux\n")
raise RuntimeError("Error initializing")
exec_mode = hoomd.ExecutionConfiguration.executionMode.AUTO
elif globals.options.mode == "cpu":
exec_mode = hoomd.ExecutionConfiguration.executionMode.CPU
elif globals.options.mode == "gpu":
exec_mode = hoomd.ExecutionConfiguration.executionMode.GPU
else:
raise RuntimeError("Invalid mode")
# convert None options to defaults
if globals.options.gpu is None:
gpu_id = -1
else:
gpu_id = int(globals.options.gpu)
if globals.options.nrank is None:
nrank = 0
else:
nrank = int(globals.options.nrank)
# create the specified configuration
exec_conf = hoomd.ExecutionConfiguration(exec_mode, gpu_id,
globals.options.min_cpu,
globals.options.ignore_display,
globals.msg, nrank)
# if gpu_error_checking is set, enable it on the GPU
if globals.options.gpu_error_checking:
exec_conf.setCUDAErrorChecking(True)
globals.exec_conf = exec_conf
return exec_conf
def _create_domain_decomposition(box):
if not hoomd.is_MPI_available():
return None
# if we are only running on one processor, we use optimized code paths
# for single-GPU execution
if globals.exec_conf.getNRanks() == 1:
return None
# okay, we want a decomposition but one isn't set, so make a default one
if globals.decomposition is None:
# this is happening transparently to the user, so hush this up
util._disable_status_lines = True
globals.decomposition = comm.decomposition()
util._disable_status_lines = False
return globals.decomposition._make_cpp_decomposition(box)
def _create_exec_conf():
# use a cached execution configuration if available
if globals.exec_conf is not None:
return globals.exec_conf
mpi_available = hoomd.is_MPI_available()
# error out on nyx/flux if the auto mode is set
if globals.options.mode == "auto":
if (re.match("flux*", platform.node()) is not None) or (re.match("nyx*", platform.node()) is not None):
globals.msg.error("--mode=gpu or --mode=cpu must be specified on nyx/flux\n")
raise RuntimeError("Error initializing")
exec_mode = hoomd.ExecutionConfiguration.executionMode.AUTO
elif globals.options.mode == "cpu":
exec_mode = hoomd.ExecutionConfiguration.executionMode.CPU
elif globals.options.mode == "gpu":
exec_mode = hoomd.ExecutionConfiguration.executionMode.GPU
else:
raise RuntimeError("Invalid mode")
# convert None options to defaults
if globals.options.gpu is None:
gpu_id = -1
else:
gpu_id = int(globals.options.gpu)
if globals.options.nrank is None:
nrank = 0
else:
nrank = int(globals.options.nrank)
# create the specified configuration
exec_conf = hoomd.ExecutionConfiguration(
exec_mode, gpu_id, globals.options.min_cpu, globals.options.ignore_display, globals.msg, nrank
)
# if gpu_error_checking is set, enable it on the GPU
if globals.options.gpu_error_checking:
exec_conf.setCUDAErrorChecking(True)
globals.exec_conf = exec_conf
return exec_conf
def __init__(self, r_cut):
util.print_status_line();
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData().getDomainDecomposition():
globals.msg.error("wall.lj is not supported in multi-processor simulations.\n\n")
raise RuntimeError("Error setting up wall potential.")
# initialize the base class
force._force.__init__(self);
# create the c++ mirror class
self.cpp_force = hoomd.LJWallForceCompute(globals.system_definition, r_cut);
# variable for tracking which particle type coefficients have been set
self.particle_types_set = [];
globals.system.addCompute(self.cpp_force, self.force_name);
def __init__(self, group, nlist=None):
util.print_status_line()
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData(
).getDomainDecomposition():
globals.msg.error(
"charge.pppm is not supported in multi-processor simulations.\n\n"
)
raise RuntimeError("Error initializing PPPM.")
# initialize the base class
force._force.__init__(self)
# create the c++ mirror class
# PPPM doesn't really need a neighbor list, so subscribe call back as None
if nlist is None:
self.nlist = nl._subscribe_global_nlist(lambda: None)
else: # otherwise, subscribe the specified neighbor list
self.nlist = nlist
self.nlist.subscribe(lambda: None)
self.nlist.update_rcut()
if not globals.exec_conf.isCUDAEnabled():
self.cpp_force = hoomd.PPPMForceCompute(globals.system_definition,
self.nlist.cpp_nlist,
group.cpp_group)
else:
self.cpp_force = hoomd.PPPMForceComputeGPU(
globals.system_definition, self.nlist.cpp_nlist,
group.cpp_group)
globals.system.addCompute(self.cpp_force, self.force_name)
# error check flag - must be set to true by set_params in order for the run() to commence
self.params_set = False
# initialize the short range part of electrostatics
util._disable_status_lines = True
self.ewald = pair.ewald(r_cut=0.0, nlist=self.nlist)
util._disable_status_lines = False
def _create_exec_conf():
# use a cached execution configuration if available
if globals.exec_conf is not None:
return globals.exec_conf
mpi_available = hoomd.is_MPI_available();
# error out on nyx/flux if the auto mode is set
if globals.options.mode == 'auto':
host = _get_proc_name()
if "flux" in host or "nyx" in host:
globals.msg.error("--mode=gpu or --mode=cpu must be specified on nyx/flux\n");
raise RuntimeError("Error initializing");
exec_mode = hoomd.ExecutionConfiguration.executionMode.AUTO;
elif globals.options.mode == "cpu":
exec_mode = hoomd.ExecutionConfiguration.executionMode.CPU;
elif globals.options.mode == "gpu":
exec_mode = hoomd.ExecutionConfiguration.executionMode.GPU;
else:
raise RuntimeError("Invalid mode");
# convert None options to defaults
if globals.options.gpu is None:
gpu_id = -1;
else:
gpu_id = int(globals.options.gpu);
if globals.options.nrank is None:
nrank = 0;
else:
nrank = int(globals.options.nrank);
# create the specified configuration
exec_conf = hoomd.ExecutionConfiguration(exec_mode, gpu_id, globals.options.min_cpu, globals.options.ignore_display, globals.msg, nrank);
# if gpu_error_checking is set, enable it on the GPU
if globals.options.gpu_error_checking:
exec_conf.setCUDAErrorChecking(True);
globals.exec_conf = exec_conf;
return exec_conf;
def __init__(self, filename="dump", period=None, file1=None, file2=None, compress=True, phase=-1):
util.print_status_line();
globals.msg.warning("dump.bin is deprecated and will be removed in the next release");
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData().getDomainDecomposition():
globals.msg.error("dump.bin is not supported in multi-processor simulations.\n\n")
raise RuntimeError("Error writing restart data.")
# initialize base class
analyze._analyzer.__init__(self);
# create the c++ mirror class
self.cpp_analyzer = hoomd.HOOMDBinaryDumpWriter(globals.system_definition, filename);
self.cpp_analyzer.enableCompression(compress)
# handle the alternation setting
# first, check that they are both set
if (file1 is not None and file2 is None) or (file2 is not None and file1 is None):
globals.msg.error("file1 and file2 must either both be set or both left as None.\n");
raise RuntimeError('Error initializing dump.bin');
if file1 is not None:
self.cpp_analyzer.setAlternatingWrites(file1, file2)
if period is None:
globals.msg.warning("Alternating file output set for dump.bin, but period is not set.\n");
globals.msg.warning("No output will be written.\n");
globals.msg.warning("dump.bin does not support triclinic boxes.\n");
globals.msg.warning("dump.bin is deprecated and will be replaced in v1.1.0\n");
if period is not None:
self.setupAnalyzer(period, phase);
self.enabled = True;
self.prev_period = 1;
elif filename != "dump":
util._disable_status_lines = True;
self.write(filename);
util._disable_status_lines = False;
else:
self.enabled = False;
def __init__(self, T, period=1):
util.print_status_line();
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData().getDomainDecomposition():
globals.msg.error("update.rescale_temp not supported in multi-processor simulations.\n\n")
raise RuntimeError("Error setting up updater.")
# initialize base class
_updater.__init__(self);
# setup the variant inputs
T = variant._setup_variant_input(T);
# create the compute thermo
thermo = compute._get_unique_thermo(group=globals.group_all);
# create the c++ mirror class
self.cpp_updater = hoomd.TempRescaleUpdater(globals.system_definition, thermo.cpp_compute, T.cpp_variant);
self.setupUpdater(period);
def __init__(self, T, period=1):
util.print_status_line()
# Error out in MPI simulations
if hoomd.is_MPI_available():
if globals.system_definition.getParticleData().getDomainDecomposition():
globals.msg.error("update.rescale_temp not supported in multi-processor simulations.\n\n")
raise RuntimeError("Error setting up updater.")
# initialize base class
_updater.__init__(self)
# setup the variant inputs
T = variant._setup_variant_input(T)
# create the compute thermo
thermo = compute._get_unique_thermo(group=globals.group_all)
# create the c++ mirror class
self.cpp_updater = hoomd.TempRescaleUpdater(globals.system_definition, thermo.cpp_compute, T.cpp_variant)
self.setupUpdater(period)
def __init__(self,
x=True,
y=True,
z=True,
tolerance=1.02,
maxiter=1,
period=1000,
phase=-1):
util.print_status_line()
# initialize base class
_updater.__init__(self)
# balancing cannot be done without mpi
if not hoomd.is_MPI_available():
globals.msg.warning(
"Ignoring balance command, not supported in current configuration.\n"
)
return
# create the c++ mirror class
if not globals.exec_conf.isCUDAEnabled():
self.cpp_updater = hoomd.LoadBalancer(globals.system_definition,
globals.decomposition.cpp_dd)
else:
self.cpp_updater = hoomd.LoadBalancerGPU(
globals.system_definition, globals.decomposition.cpp_dd)
self.setupUpdater(period, phase)
# stash arguments to metadata
self.metadata_fields = ['tolerance', 'maxiter', 'period', 'phase']
self.period = period
self.phase = phase
# configure the parameters
util._disable_status_lines = True
self.set_params(x, y, z, tolerance, maxiter)
util._disable_status_lines = False
def __init__(self, r_cut):
util.print_status_line()
# Error out in MPI simulations
if (hoomd.is_MPI_available()):
if globals.system_definition.getParticleData(
).getDomainDecomposition():
globals.msg.error(
"wall.lj is not supported in multi-processor simulations.\n\n"
)
raise RuntimeError("Error setting up wall potential.")
# initialize the base class
force._force.__init__(self)
# create the c++ mirror class
self.cpp_force = hoomd.LJWallForceCompute(globals.system_definition,
r_cut)
# variable for tracking which particle type coefficients have been set
self.particle_types_set = []
globals.system.addCompute(self.cpp_force, self.force_name)
def _parse_command_line():
parser = OptionParser();
parser.add_option("--mode", dest="mode", help="Execution mode (cpu or gpu)");
parser.add_option("--gpu", dest="gpu", help="GPU on which to execute");
parser.add_option("--ncpu", dest="ncpu", help="Number of CPU cores on which to execute");
parser.add_option("--gpu_error_checking", dest="gpu_error_checking", action="store_true", default=False, help="Enable error checking on the GPU");
parser.add_option("--minimize-cpu-usage", dest="min_cpu", action="store_true", default=False, help="Enable to keep the CPU usage of HOOMD to a bare minimum (will degrade overall performance somewhat)");
parser.add_option("--ignore-display-gpu", dest="ignore_display", action="store_true", default=False, help="Attempt to avoid running on the display GPU");
parser.add_option("--notice-level", dest="notice_level", help="Minimum level of notice messages to print");
parser.add_option("--msg-file", dest="msg_file", help="Name of file to write messages to");
parser.add_option("--shared-msg-file", dest="shared_msg_file", help="(MPI only) Name of shared file to write message to (append partition #)");
parser.add_option("--nrank", dest="nrank", help="(MPI) Number of ranks to include in a partition");
parser.add_option("--nx", dest="nx", help="(MPI) Number of domains along the x-direction");
parser.add_option("--ny", dest="ny", help="(MPI) Number of domains along the y-direction");
parser.add_option("--nz", dest="nz", help="(MPI) Number of domains along the z-direction");
parser.add_option("--linear", dest="linear", action="store_true", default=False, help="(MPI only) Force a slab (1D) decomposition along the z-direction");
parser.add_option("--onelevel", dest="onelevel", action="store_true", default=False, help="(MPI only) Disable two-level (node-local) decomposition");
parser.add_option("--user", dest="user", help="User options");
(cmd_options, args) = parser.parse_args();
# chedk for valid mode setting
if cmd_options.mode is not None:
if not (cmd_options.mode == "cpu" or cmd_options.mode == "gpu"):
parser.error("--mode must be either cpu or gpu");
# check for sane options
if cmd_options.mode == "cpu" and (cmd_options.gpu is not None):
parser.error("--mode=cpu cannot be specified along with --gpu")
if cmd_options.mode == "gpu" and (cmd_options.ncpu is not None):
parser.error("--mode=gpu cannot be specified along with --ncpu")
# set the mode to gpu if the gpu # was set
if cmd_options.gpu is not None and cmd_options.mode is None:
cmd_options.mode = "gpu"
# set the mode to cpu if the ncpu was set
if cmd_options.ncpu is not None and cmd_options.mode is None:
cmd_options.mode = "cpu"
# convert ncpu to an integer
if cmd_options.ncpu is not None:
try:
cmd_options.ncpu = int(cmd_options.ncpu);
except ValueError:
parser.error('--ncpu must be an integer')
# convert gpu to an integer
if cmd_options.gpu:
try:
cmd_options.gpu = int(cmd_options.gpu);
except ValueError:
parser.error('--gpu must be an integer')
# convert notice_level to an integer
if cmd_options.notice_level is not None:
try:
cmd_options.notice_level = int(cmd_options.notice_level);
except ValueError:
parser.error('--notice-level must be an integer')
# Convert nx to an integer
if cmd_options.nx is not None:
if not hoomd.is_MPI_available():
globals.msg.error("The --nx option is only avaible in MPI builds.\n");
raise RuntimeError('Error setting option');
try:
cmd_options.nx = int(cmd_options.nx);
except ValueError:
parser.error('--nx must be an integer')
# Convert ny to an integer
if cmd_options.ny is not None:
if not hoomd.is_MPI_available():
globals.msg.error("The --ny option is only avaible in MPI builds.\n");
raise RuntimeError('Error setting option');
try:
cmd_options.ny = int(cmd_options.ny);
except ValueError:
parser.error('--ny must be an integer')
# Convert nz to an integer
if cmd_options.nz is not None:
if not hoomd.is_MPI_available():
globals.msg.error("The --nz option is only avaible in MPI builds.\n");
raise RuntimeError('Error setting option');
try:
cmd_options.nz = int(cmd_options.nz);
except ValueError:
parser.error('--nz must be an integer')
# copy command line options over to global options
globals.options.mode = cmd_options.mode;
globals.options.gpu = cmd_options.gpu;
globals.options.ncpu = cmd_options.ncpu;
globals.options.gpu_error_checking = cmd_options.gpu_error_checking;
globals.options.min_cpu = cmd_options.min_cpu;
globals.options.ignore_display = cmd_options.ignore_display;
globals.options.nx = cmd_options.nx;
globals.options.ny = cmd_options.ny;
globals.options.nz = cmd_options.nz;
globals.options.linear = cmd_options.linear
globals.options.onelevel = cmd_options.onelevel
if cmd_options.notice_level is not None:
globals.options.notice_level = cmd_options.notice_level;
globals.msg.setNoticeLevel(globals.options.notice_level);
if cmd_options.msg_file is not None:
globals.options.msg_file = cmd_options.msg_file;
globals.msg.openFile(globals.options.msg_file);
if cmd_options.shared_msg_file is not None:
if not hoomd.is_MPI_available():
globals.msg.error("Shared log files are only available in MPI builds.\n");
raise RuntimeError('Error setting option');
globals.options.shared_msg_file = cmd_options.shared_msg_file;
globals.msg.setSharedFile(globals.options.shared_msg_file);
if cmd_options.nrank is not None:
if not hoomd.is_MPI_available():
globals.msg.error("The --nrank option is only avaible in MPI builds.\n");
raise RuntimeError('Error setting option');
# check validity
nrank = int(cmd_options.nrank)
if (hoomd.ExecutionConfiguration.getNRanksGlobal() % nrank):
globals.msg.error("Total number of ranks is not a multiple of --nrank\n");
raise RuntimeError('Error checking option');
globals.options.nrank = nrank
if cmd_options.user is not None:
globals.options.user = shlex.split(cmd_options.user);
def barrier_all():
if hoomd.is_MPI_available():
hoomd.mpi_barrier_world();
def get_num_ranks():
hoomd_script.context._verify_init();
if hoomd.is_MPI_available():
return globals.exec_conf.getNRanks();
else:
return 1;
def barrier_all():
if hoomd.is_MPI_available():
hoomd.mpi_barrier_world()
def barrier():
hoomd_script.context._verify_init()
if hoomd.is_MPI_available():
globals.exec_conf.barrier()
def barrier():
hoomd_script.context._verify_init();
if hoomd.is_MPI_available():
globals.exec_conf.barrier()
def get_num_ranks():
hoomd_script.context._verify_init()
if hoomd.is_MPI_available():
return globals.exec_conf.getNRanks()
else:
return 1
# 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;
## Get the current simulation time step
#
# \returns current simulation time step
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();
# Check to see if we are built without MPI support and the user used mpirun
if (not hoomd.is_MPI_available()) and ('OMPI_COMM_WORLD_RANK' in os.environ or 'MV2_COMM_WORLD_LOCAL_RANK' in os.environ):
print('HOOMD-blue is built without MPI support, but seems to have been launched with mpirun');
print('exiting now to prevent many sequential jobs from starting');
raise RuntimeError('Error launching hoomd')
def _get_proc_name():
if hoomd.is_MPI_available():
return hoomd.get_mpi_proc_name()
else:
return platform.node()
def _get_proc_name():
if hoomd.is_MPI_available():
return hoomd.get_mpi_proc_name()
else:
return platform.node()
def _parse_command_line():
parser = OptionParser();
parser.add_option("--mode", dest="mode", help="Execution mode (cpu or gpu)", default='auto');
parser.add_option("--gpu", dest="gpu", help="GPU on which to execute");
parser.add_option("--gpu_error_checking", dest="gpu_error_checking", action="store_true", default=False, help="Enable error checking on the GPU");
parser.add_option("--minimize-cpu-usage", dest="min_cpu", action="store_true", default=False, help="Enable to keep the CPU usage of HOOMD to a bare minimum (will degrade overall performance somewhat)");
parser.add_option("--ignore-display-gpu", dest="ignore_display", action="store_true", default=False, help="Attempt to avoid running on the display GPU");
parser.add_option("--notice-level", dest="notice_level", help="Minimum level of notice messages to print");
parser.add_option("--msg-file", dest="msg_file", help="Name of file to write messages to");
parser.add_option("--shared-msg-file", dest="shared_msg_file", help="(MPI only) Name of shared file to write message to (append partition #)");
parser.add_option("--nrank", dest="nrank", help="(MPI) Number of ranks to include in a partition");
parser.add_option("--nx", dest="nx", help="(MPI) Number of domains along the x-direction");
parser.add_option("--ny", dest="ny", help="(MPI) Number of domains along the y-direction");
parser.add_option("--nz", dest="nz", help="(MPI) Number of domains along the z-direction");
parser.add_option("--linear", dest="linear", action="store_true", default=False, help="(MPI only) Force a slab (1D) decomposition along the z-direction");
parser.add_option("--onelevel", dest="onelevel", action="store_true", default=False, help="(MPI only) Disable two-level (node-local) decomposition");
parser.add_option("--user", dest="user", help="User options");
(cmd_options, args) = parser.parse_args();
# chedk for valid mode setting
if cmd_options.mode is not None:
if not (cmd_options.mode == "cpu" or cmd_options.mode == "gpu" or cmd_options.mode == "auto"):
parser.error("--mode must be either cpu, gpu, or auto");
# check for sane options
if cmd_options.mode == "cpu" and (cmd_options.gpu is not None):
parser.error("--mode=cpu cannot be specified along with --gpu")
# set the mode to gpu if the gpu # was set
if cmd_options.gpu is not None and cmd_options.mode == 'auto':
cmd_options.mode = "gpu"
# convert gpu to an integer
if cmd_options.gpu is not None:
try:
cmd_options.gpu = int(cmd_options.gpu);
except ValueError:
parser.error('--gpu must be an integer')
# convert notice_level to an integer
if cmd_options.notice_level is not None:
try:
cmd_options.notice_level = int(cmd_options.notice_level);
except ValueError:
parser.error('--notice-level must be an integer')
# Convert nx to an integer
if cmd_options.nx is not None:
if not hoomd.is_MPI_available():
globals.msg.error("The --nx option is only avaible in MPI builds.\n");
raise RuntimeError('Error setting option');
try:
cmd_options.nx = int(cmd_options.nx);
except ValueError:
parser.error('--nx must be an integer')
# Convert ny to an integer
if cmd_options.ny is not None:
if not hoomd.is_MPI_available():
globals.msg.error("The --ny option is only avaible in MPI builds.\n");
raise RuntimeError('Error setting option');
try:
cmd_options.ny = int(cmd_options.ny);
except ValueError:
parser.error('--ny must be an integer')
# Convert nz to an integer
if cmd_options.nz is not None:
if not hoomd.is_MPI_available():
globals.msg.error("The --nz option is only avaible in MPI builds.\n");
raise RuntimeError('Error setting option');
try:
cmd_options.nz = int(cmd_options.nz);
except ValueError:
parser.error('--nz must be an integer')
# copy command line options over to global options
globals.options.mode = cmd_options.mode;
globals.options.gpu = cmd_options.gpu;
globals.options.gpu_error_checking = cmd_options.gpu_error_checking;
globals.options.min_cpu = cmd_options.min_cpu;
globals.options.ignore_display = cmd_options.ignore_display;
globals.options.nx = cmd_options.nx;
globals.options.ny = cmd_options.ny;
globals.options.nz = cmd_options.nz;
globals.options.linear = cmd_options.linear
globals.options.onelevel = cmd_options.onelevel
if cmd_options.notice_level is not None:
globals.options.notice_level = cmd_options.notice_level;
globals.msg.setNoticeLevel(globals.options.notice_level);
if cmd_options.msg_file is not None:
globals.options.msg_file = cmd_options.msg_file;
globals.msg.openFile(globals.options.msg_file);
if cmd_options.shared_msg_file is not None:
if not hoomd.is_MPI_available():
globals.msg.error("Shared log files are only available in MPI builds.\n");
raise RuntimeError('Error setting option');
globals.options.shared_msg_file = cmd_options.shared_msg_file;
globals.msg.setSharedFile(globals.options.shared_msg_file);
if cmd_options.nrank is not None:
if not hoomd.is_MPI_available():
globals.msg.error("The --nrank option is only avaible in MPI builds.\n");
raise RuntimeError('Error setting option');
# check validity
nrank = int(cmd_options.nrank)
if (hoomd.ExecutionConfiguration.getNRanksGlobal() % nrank):
globals.msg.error("Total number of ranks is not a multiple of --nrank\n");
raise RuntimeError('Error checking option');
globals.options.nrank = nrank
if cmd_options.user is not None:
globals.options.user = shlex.split(cmd_options.user);
def get_num_ranks():
if hoomd.is_MPI_available():
return globals.exec_conf.getNRanks()
else:
return 1
#
# Example:
# ~~~~~
# from hoomd_script import *
# init.read_xml("init.xml");
# # setup....
# run(30000); # warm up and auto-tune kernel block sizes
# option.set_autotuner_params(enable=False); # prevent block sizes from further autotuning
# cuda_profile_start();
# run(100);
# ~~~~~
def cuda_profile_start():
hoomd.cuda_profile_start()
## Stop CUDA profiling
# \sa cuda_profile_start();
def cuda_profile_stop():
hoomd.cuda_profile_stop()
# Check to see if we are built without MPI support and the user used mpirun
if (not hoomd.is_MPI_available()) and ('OMPI_COMM_WORLD_RANK' in os.environ
or 'MV2_COMM_WORLD_LOCAL_RANK'
in os.environ):
print(
'HOOMD-blue is built without MPI support, but seems to have been launched with mpirun'
)
print('exiting now to prevent many sequential jobs from starting')
raise RuntimeError('Error launching hoomd')
def _create_exec_conf():
# use a cached execution configuration if available
if globals.exec_conf is not None:
return globals.exec_conf
mpi_available = hoomd.is_MPI_available()
# set the openmp thread limits
if globals.options.ncpu is not None:
if globals.options.ncpu > hoomd.get_num_procs():
globals.msg.warning(
"Requesting more CPU cores than there are available in the system\n"
)
hoomd.set_num_threads(globals.options.ncpu)
# if no command line options were specified, create a default ExecutionConfiguration
if globals.options.mode is None:
if mpi_available:
if globals.options.nrank is not None:
exec_conf = hoomd.ExecutionConfiguration(
globals.options.min_cpu, globals.options.ignore_display,
globals.msg, True, globals.options.nrank)
else:
exec_conf = hoomd.ExecutionConfiguration(
globals.options.min_cpu, globals.options.ignore_display,
globals.msg, True)
else:
exec_conf = hoomd.ExecutionConfiguration(
globals.options.min_cpu, globals.options.ignore_display,
globals.msg)
else:
# determine the GPU on which to execute
if globals.options.gpu is not None:
gpu_id = int(globals.options.gpu)
else:
gpu_id = -1
# create the specified configuration
if globals.options.mode == "cpu":
if mpi_available:
if globals.options.nrank is not None:
exec_conf = hoomd.ExecutionConfiguration(
hoomd.ExecutionConfiguration.executionMode.CPU, gpu_id,
globals.options.min_cpu,
globals.options.ignore_display, globals.msg, True,
globals.options.nrank)
else:
exec_conf = hoomd.ExecutionConfiguration(
hoomd.ExecutionConfiguration.executionMode.CPU, gpu_id,
globals.options.min_cpu,
globals.options.ignore_display, globals.msg, True)
else:
exec_conf = hoomd.ExecutionConfiguration(
hoomd.ExecutionConfiguration.executionMode.CPU, gpu_id,
globals.options.min_cpu, globals.options.ignore_display,
globals.msg)
elif globals.options.mode == "gpu":
if mpi_available:
if globals.options.nrank is not None:
exec_conf = hoomd.ExecutionConfiguration(
hoomd.ExecutionConfiguration.executionMode.GPU, gpu_id,
globals.options.min_cpu,
globals.options.ignore_display, globals.msg, True,
globals.options.nrank)
else:
exec_conf = hoomd.ExecutionConfiguration(
hoomd.ExecutionConfiguration.executionMode.GPU, gpu_id,
globals.options.min_cpu,
globals.options.ignore_display, globals.msg, True)
else:
exec_conf = hoomd.ExecutionConfiguration(
hoomd.ExecutionConfiguration.executionMode.GPU, gpu_id,
globals.options.min_cpu, globals.options.ignore_display,
globals.msg)
else:
raise RuntimeError("Error initializing")
# if gpu_error_checking is set, enable it on the GPU
if globals.options.gpu_error_checking:
exec_conf.setCUDAErrorChecking(True)
globals.exec_conf = exec_conf
return exec_conf
def get_num_ranks():
if hoomd.is_MPI_available():
return globals.exec_conf.getNRanks();
else:
return 1;
