def __init__(self, order_parameters, lattice_vectors, phases, interface_width, name):
# initialize the base class
force._force.__init__(self, name);
self.cpp_force = None;
cpp_order_parameters = hoomd.std_vector_scalar()
for l in order_parameters:
cpp_order_parameters.append(l)
cpp_lattice_vectors = _external.std_vector_int3()
for l in lattice_vectors:
if len(l) != 3:
globals.msg.error("List of input lattice vectors not a list of triples.\n")
raise RuntimeError('Error creating external ordering potential.')
cpp_lattice_vectors.append(hoomd.make_int3(l[0], l[1], l[2]))
cpp_phases = hoomd.std_vector_scalar()
for l in phases:
cpp_phases.append(l)
cpp_interface_width = float(interface_width)
if not globals.exec_conf.isCUDAEnabled():
self.cpp_force = _external.OrderingExternal(globals.system_definition, cpp_order_parameters, cpp_lattice_vectors, cpp_phases, cpp_interface_width, self.name)
else:
self.cpp_force = _external.OrderingExternalGPU(globals.system_definition, cpp_order_parameters, cpp_lattice_vectors, cpp_phases, cpp_interface_width, self.name)
globals.system.addCompute(self.cpp_force, self.force_name)
self.enabled = True;
def _make_cpp_decomposition(self, box):
# if the box is uniform in all directions, just use these values
if self.uniform_x and self.uniform_y and self.uniform_z:
self.cpp_dd = hoomd.DomainDecomposition(globals.exec_conf, box.getL(), self.nx, self.ny, self.nz, not globals.options.onelevel)
return self.cpp_dd
# otherwise, make the fractional decomposition
try:
fxs = hoomd.std_vector_scalar()
fys = hoomd.std_vector_scalar()
fzs = hoomd.std_vector_scalar()
# if uniform, correct the fractions to be uniform as well
if self.uniform_x and self.nx > 0:
self.x = [1.0/self.nx]*(self.nx-1)
if self.uniform_y and self.ny > 0:
self.y = [1.0/self.ny]*(self.ny-1)
if self.uniform_z and self.nz > 0:
self.z = [1.0/self.nz]*(self.nz-1)
sum_x = sum_y = sum_z = 0.0
tol = 1.0e-5
for i in self.x:
if i <= -tol or i >= 1.0 - tol:
globals.msg.error("comm.decomposition: fraction must be between 0.0 and 1.0\n")
raise RuntimeError("Fractional decomposition must be between 0.0 and 1.0")
fxs.append(i)
sum_x += i
if sum_x >= 1.0 - tol or sum_x <= -tol:
globals.msg.error("comm.decomposition: fraction must be between 0.0 and 1.0\n")
raise RuntimeError("Sum of decomposition in x must lie between 0.0 and 1.0")
for i in self.y:
if i <= -tol or i >= 1.0 - tol:
globals.msg.error("comm.decomposition: fraction must be between 0.0 and 1.0\n")
raise RuntimeError("Fractional decomposition must be between 0.0 and 1.0")
fys.append(i)
sum_y += i
if sum_y >= 1.0 - tol or sum_y <= -tol:
globals.msg.error("comm.decomposition: fraction must be between 0.0 and 1.0\n")
raise RuntimeError("Sum of decomposition in y must lie between 0.0 and 1.0")
for i in self.z:
if i <= -tol or i >= 1.0 - tol:
globals.msg.error("comm.decomposition: fraction must be between 0.0 and 1.0\n")
raise RuntimeError("Fractional decomposition must be between 0.0 and 1.0")
fzs.append(i)
sum_z += i
if sum_z >= 1.0 - tol or sum_z <= -tol:
globals.msg.error("comm.decomposition: fraction must be between 0.0 and 1.0\n")
raise RuntimeError("Sum of decomposition in z must lie between 0.0 and 1.0")
self.cpp_dd = hoomd.DomainDecomposition(globals.exec_conf, box.getL(), fxs, fys, fzs)
return self.cpp_dd
except TypeError as te:
globals.msg.error("Fractional cuts must be iterable (list, tuple, etc.)\n")
raise te
def update_angle_table(self, atype, func, coeff):
# allocate arrays to store V and F
Vtable = hoomd.std_vector_scalar()
Ttable = hoomd.std_vector_scalar()
# calculate dth
dth = math.pi / float(self.width - 1)
# evaluate each point of the function
for i in range(0, self.width):
theta = dth * i
(V, T) = func(theta, **coeff)
# fill out the tables
Vtable.append(V)
Ttable.append(T)
# pass the tables on to the underlying cpp compute
self.cpp_force.setTable(atype, Vtable, Ttable)
def update_dihedral_table(self, atype, func, coeff):
# allocate arrays to store V and F
Vtable = hoomd.std_vector_scalar();
Ttable = hoomd.std_vector_scalar();
# calculate dth
dth = 2.0*math.pi / float(self.width-1);
# evaluate each point of the function
for i in range(0, self.width):
theta = -math.pi+dth * i;
(V,T) = func(theta, **coeff);
# fill out the tables
Vtable.append(V);
Ttable.append(T);
# pass the tables on to the underlying cpp compute
self.cpp_force.setTable(atype, Vtable, Ttable);
def update_bond_table(self, btype, func, rmin, rmax, coeff):
# allocate arrays to store V and F
Vtable = hoomd.std_vector_scalar()
Ftable = hoomd.std_vector_scalar()
# calculate dr
dr = (rmax - rmin) / float(self.width - 1)
# evaluate each point of the function
for i in range(0, self.width):
r = rmin + dr * i
(V, F) = func(r, rmin, rmax, **coeff)
# fill out the tables
Vtable.append(V)
Ftable.append(F)
# pass the tables on to the underlying cpp compute
self.cpp_force.setTable(btype, Vtable, Ftable, rmin, rmax)
def update_bond_table(self, btype, func, rmin, rmax, coeff):
# allocate arrays to store V and F
Vtable = hoomd.std_vector_scalar();
Ftable = hoomd.std_vector_scalar();
# calculate dr
dr = (rmax - rmin) / float(self.width-1);
# evaluate each point of the function
for i in range(0, self.width):
r = rmin + dr * i;
(V,F) = func(r, rmin, rmax, **coeff);
# fill out the tables
Vtable.append(V);
Ftable.append(F);
# pass the tables on to the underlying cpp compute
self.cpp_force.setTable(btype, Vtable, Ftable, rmin, rmax);
def __init__(self, mode, lattice_vectors, name=None, sigma=1.0, offs=0.0):
util.print_status_line()
if name is not None:
name = "_" + name
suffix = name
else:
suffix = ""
_collective_variable.__init__(self, sigma, name)
if len(lattice_vectors) == 0:
globals.msg.error(
"cv.lamellar: List of supplied latice vectors is empty.\n")
raise RuntimeEror('Error creating collective variable.')
if type(mode) != type(dict()):
globals.msg.error(
"cv.lamellar: Mode amplitudes specified incorrectly.\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode = hoomd.std_vector_scalar()
for i in range(
0,
globals.system_definition.getParticleData().getNTypes()):
t = globals.system_definition.getParticleData().getNameByType(i)
if t not in mode.keys():
globals.msg.error(
"cv.lamellar: Missing mode amplitude for particle type " +
t + ".\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode.append(mode[t])
cpp_lattice_vectors = _metadynamics.std_vector_int3()
for l in lattice_vectors:
if len(l) != 3:
globals.msg.error(
"cv.lamellar: List of input lattice vectors not a list of triples.\n"
)
raise RuntimeError('Error creating collective variable.')
cpp_lattice_vectors.append(hoomd.make_int3(l[0], l[1], l[2]))
if not globals.exec_conf.isCUDAEnabled():
self.cpp_force = _metadynamics.LamellarOrderParameter(
globals.system_definition, cpp_mode, cpp_lattice_vectors, offs,
suffix)
else:
self.cpp_force = _metadynamics.LamellarOrderParameterGPU(
globals.system_definition, cpp_mode, cpp_lattice_vectors, offs,
suffix)
globals.system.addCompute(self.cpp_force, self.force_name)
def __init__(self, order_parameters, lattice_vectors, phases,
interface_width, name):
# initialize the base class
force._force.__init__(self, name)
self.cpp_force = None
cpp_order_parameters = hoomd.std_vector_scalar()
for l in order_parameters:
cpp_order_parameters.append(l)
cpp_lattice_vectors = _external.std_vector_int3()
for l in lattice_vectors:
if len(l) != 3:
globals.msg.error(
"List of input lattice vectors not a list of triples.\n")
raise RuntimeError(
'Error creating external ordering potential.')
cpp_lattice_vectors.append(hoomd.make_int3(l[0], l[1], l[2]))
cpp_phases = hoomd.std_vector_scalar()
for l in phases:
cpp_phases.append(l)
cpp_interface_width = float(interface_width)
if not globals.exec_conf.isCUDAEnabled():
self.cpp_force = _external.OrderingExternal(
globals.system_definition, cpp_order_parameters,
cpp_lattice_vectors, cpp_phases, cpp_interface_width,
self.name)
else:
self.cpp_force = _external.OrderingExternalGPU(
globals.system_definition, cpp_order_parameters,
cpp_lattice_vectors, cpp_phases, cpp_interface_width,
self.name)
globals.system.addCompute(self.cpp_force, self.force_name)
self.enabled = True
def __init__(self, filename, mode, lattice_vectors, phases, grid, period=1, endtime=1, overwrite=False):
util.print_status_line();
# initialize base class
_analyzer.__init__(self);
if len(lattice_vectors) == 0:
globals.msg.error("analyze.sq: List of supplied latice vectors is empty.\n")
raise RuntimeEror('Error creating collective variable.')
if len(lattice_vectors) != len(phases):
globals.msg.error("analyze.sq: #phases is not equal to #lattice_vectors.\n")
raise RuntimeEror('Error creating collective variable.')
if type(mode) != type(dict()):
globals.msg.error("analyze.sq: Mode amplitudes specified incorrectly.\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode = hoomd.std_vector_scalar()
for i in range(0, globals.system_definition.getParticleData().getNTypes()):
t = globals.system_definition.getParticleData().getNameByType(i)
if t not in mode.keys():
globals.msg.error("cv.lamellar: Missing mode amplitude for particle type " + t + ".\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode.append(mode[t])
cpp_lattice_vectors = _CollectiveVariable_plugin.std_vector_int3()
for l in lattice_vectors:
if len(l) != 3:
globals.msg.error("cv.lamellar: List of input lattice vectors not a list of triples.\n")
raise RuntimeError('Error creating collective variable.')
cpp_lattice_vectors.append(hoomd.make_int3(l[0], l[1], l[2]))
cpp_phases = _CollectiveVariable_plugin.std_vector_scalar()
for l in phases:
cpp_phases.append(l)
cpp_grid = _CollectiveVariable_plugin.std_vector_uint()
for l in grid:
cpp_grid.append(l)
# initialize the reflected c++ class
if not globals.exec_conf.isCUDAEnabled():
self.cpp_analyzer = _CollectiveVariable_plugin.CollectiveVariable(globals.system_definition, cpp_mode, cpp_lattice_vectors, cpp_phases, cpp_grid, endtime, filename, overwrite);
else:
self.cpp_analyzer = _CollectiveVariable_plugin.CollectiveVariableGPU(globals.system_definition, cpp_mode, cpp_lattice_vectors, cpp_phases, cpp_grid, endtime,filename, overwrite);
self.setupAnalyzer(period)
def __init__(self, qstar, mode, nx, ny=None, nz=None, name=None,sigma=1.0,zero_modes=None):
util.print_status_line()
if name is not None:
name = "_" + name
suffix = name
else:
suffix = ""
if ny is None:
ny = nx
if nz is None:
nz = nx
_collective_variable.__init__(self, sigma, name)
if type(mode) != type(dict()):
globals.msg.error("cv.mesh: Mode amplitudes specified incorrectly.\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode = hoomd.std_vector_scalar()
for i in range(0, globals.system_definition.getParticleData().getNTypes()):
t = globals.system_definition.getParticleData().getNameByType(i)
if t not in mode.keys():
globals.msg.error("cv.mesh: Missing mode amplitude for particle type " + t + ".\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode.append(mode[t])
cpp_zero_modes = _metadynamics.std_vector_int3()
if zero_modes is not None:
for l in zero_modes:
if len(l) != 3:
globals.msg.error("cv.lamellar: List of modes to zero not a list of triples.\n")
raise RuntimeError('Error creating collective variable.')
cpp_zero_modes.append(hoomd.make_int3(l[0], l[1], l[2]))
if not globals.exec_conf.isCUDAEnabled():
self.cpp_force = _metadynamics.OrderParameterMesh(globals.system_definition, nx,ny,nz,qstar, cpp_mode, cpp_zero_modes)
else:
self.cpp_force = _metadynamics.OrderParameterMeshGPU(globals.system_definition, nx,ny,nz,qstar, cpp_mode, cpp_zero_modes)
globals.system.addCompute(self.cpp_force, self.force_name)
def __init__(self, mode, lattice_vectors, name=None,sigma=1.0,offs=0.0):
util.print_status_line()
if name is not None:
name = "_" + name
suffix = name
else:
suffix = ""
_collective_variable.__init__(self, sigma, name)
if len(lattice_vectors) == 0:
globals.msg.error("cv.lamellar: List of supplied latice vectors is empty.\n")
raise RuntimeEror('Error creating collective variable.')
if type(mode) != type(dict()):
globals.msg.error("cv.lamellar: Mode amplitudes specified incorrectly.\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode = hoomd.std_vector_scalar()
for i in range(0, globals.system_definition.getParticleData().getNTypes()):
t = globals.system_definition.getParticleData().getNameByType(i)
if t not in mode.keys():
globals.msg.error("cv.lamellar: Missing mode amplitude for particle type " + t + ".\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode.append(mode[t])
cpp_lattice_vectors = _metadynamics.std_vector_int3()
for l in lattice_vectors:
if len(l) != 3:
globals.msg.error("cv.lamellar: List of input lattice vectors not a list of triples.\n")
raise RuntimeError('Error creating collective variable.')
cpp_lattice_vectors.append(hoomd.make_int3(l[0], l[1], l[2]))
if not globals.exec_conf.isCUDAEnabled():
self.cpp_force = _metadynamics.LamellarOrderParameter(globals.system_definition, cpp_mode, cpp_lattice_vectors, offs,suffix)
else:
self.cpp_force = _metadynamics.LamellarOrderParameterGPU(globals.system_definition, cpp_mode, cpp_lattice_vectors, offs, suffix)
globals.system.addCompute(self.cpp_force, self.force_name)
def __init__(self, filename_sq, filename_vh, mode, lattice_vectors, period=1, vanhove_endtime=1, overwrite=False):
util.print_status_line();
# initialize base class
_analyzer.__init__(self);
if len(lattice_vectors) == 0:
globals.msg.error("analyze.sq: List of supplied latice vectors is empty.\n")
raise RuntimeEror('Error creating collective variable.')
if type(mode) != type(dict()):
globals.msg.error("analyze.sq: Mode amplitudes specified incorrectly.\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode = hoomd.std_vector_scalar()
for i in range(0, globals.system_definition.getParticleData().getNTypes()):
t = globals.system_definition.getParticleData().getNameByType(i)
if t not in mode.keys():
globals.msg.error("cv.lamellar: Missing mode amplitude for particle type " + t + ".\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode.append(mode[t])
cpp_lattice_vectors = _sq_plugin.std_vector_int3()
for l in lattice_vectors:
if len(l) != 3:
globals.msg.error("cv.lamellar: List of input lattice vectors not a list of triples.\n")
raise RuntimeError('Error creating collective variable.')
cpp_lattice_vectors.append(hoomd.make_int3(l[0], l[1], l[2]))
# initialize the reflected c++ class
if not globals.exec_conf.isCUDAEnabled():
self.cpp_analyzer = _sq_plugin.StructureFactor(globals.system_definition, cpp_mode, cpp_lattice_vectors, vanhove_endtime, filename_sq, filename_vh, overwrite);
else:
self.cpp_analyzer = _sq_plugin.StructureFactorGPU(globals.system_definition, cpp_mode, cpp_lattice_vectors, vanhove_endtime, filename_sq, filename_vh, overwrite);
self.setupAnalyzer(period)
def __init__(self,
qstar,
mode,
nx,
ny=None,
nz=None,
name=None,
sigma=1.0,
zero_modes=None):
util.print_status_line()
if name is not None:
name = "_" + name
suffix = name
else:
suffix = ""
if ny is None:
ny = nx
if nz is None:
nz = nx
_collective_variable.__init__(self, sigma, name)
if type(mode) != type(dict()):
globals.msg.error(
"cv.mesh: Mode amplitudes specified incorrectly.\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode = hoomd.std_vector_scalar()
for i in range(
0,
globals.system_definition.getParticleData().getNTypes()):
t = globals.system_definition.getParticleData().getNameByType(i)
if t not in mode.keys():
globals.msg.error(
"cv.mesh: Missing mode amplitude for particle type " + t +
".\n")
raise RuntimeEror('Error creating collective variable.')
cpp_mode.append(mode[t])
cpp_zero_modes = _metadynamics.std_vector_int3()
if zero_modes is not None:
for l in zero_modes:
if len(l) != 3:
globals.msg.error(
"cv.lamellar: List of modes to zero not a list of triples.\n"
)
raise RuntimeError('Error creating collective variable.')
cpp_zero_modes.append(hoomd.make_int3(l[0], l[1], l[2]))
if not globals.exec_conf.isCUDAEnabled():
self.cpp_force = _metadynamics.OrderParameterMesh(
globals.system_definition, nx, ny, nz, qstar, cpp_mode,
cpp_zero_modes)
else:
self.cpp_force = _metadynamics.OrderParameterMeshGPU(
globals.system_definition, nx, ny, nz, qstar, cpp_mode,
cpp_zero_modes)
globals.system.addCompute(self.cpp_force, self.force_name)
def _make_cpp_decomposition(self, box):
# if the box is uniform in all directions, just use these values
if self.uniform_x and self.uniform_y and self.uniform_z:
self.cpp_dd = hoomd.DomainDecomposition(
globals.exec_conf, box.getL(), self.nx, self.ny, self.nz,
not globals.options.onelevel)
return self.cpp_dd
# otherwise, make the fractional decomposition
try:
fxs = hoomd.std_vector_scalar()
fys = hoomd.std_vector_scalar()
fzs = hoomd.std_vector_scalar()
# if uniform, correct the fractions to be uniform as well
if self.uniform_x and self.nx > 0:
self.x = [1.0 / self.nx] * (self.nx - 1)
if self.uniform_y and self.ny > 0:
self.y = [1.0 / self.ny] * (self.ny - 1)
if self.uniform_z and self.nz > 0:
self.z = [1.0 / self.nz] * (self.nz - 1)
sum_x = sum_y = sum_z = 0.0
tol = 1.0e-5
for i in self.x:
if i <= -tol or i >= 1.0 - tol:
globals.msg.error(
"comm.decomposition: fraction must be between 0.0 and 1.0\n"
)
raise RuntimeError(
"Fractional decomposition must be between 0.0 and 1.0")
fxs.append(i)
sum_x += i
if sum_x >= 1.0 - tol or sum_x <= -tol:
globals.msg.error(
"comm.decomposition: fraction must be between 0.0 and 1.0\n"
)
raise RuntimeError(
"Sum of decomposition in x must lie between 0.0 and 1.0")
for i in self.y:
if i <= -tol or i >= 1.0 - tol:
globals.msg.error(
"comm.decomposition: fraction must be between 0.0 and 1.0\n"
)
raise RuntimeError(
"Fractional decomposition must be between 0.0 and 1.0")
fys.append(i)
sum_y += i
if sum_y >= 1.0 - tol or sum_y <= -tol:
globals.msg.error(
"comm.decomposition: fraction must be between 0.0 and 1.0\n"
)
raise RuntimeError(
"Sum of decomposition in y must lie between 0.0 and 1.0")
for i in self.z:
if i <= -tol or i >= 1.0 - tol:
globals.msg.error(
"comm.decomposition: fraction must be between 0.0 and 1.0\n"
)
raise RuntimeError(
"Fractional decomposition must be between 0.0 and 1.0")
fzs.append(i)
sum_z += i
if sum_z >= 1.0 - tol or sum_z <= -tol:
globals.msg.error(
"comm.decomposition: fraction must be between 0.0 and 1.0\n"
)
raise RuntimeError(
"Sum of decomposition in z must lie between 0.0 and 1.0")
self.cpp_dd = hoomd.DomainDecomposition(globals.exec_conf,
box.getL(), fxs, fys, fzs)
return self.cpp_dd
except TypeError as te:
globals.msg.error(
"Fractional cuts must be iterable (list, tuple, etc.)\n")
raise te
