def test_melt_using_groups(self):
""" 3d Lennard-Jones melt with two atom types """
L = PyLammps()
L.units('lj')
L.atom_style('atomic')
L.lattice('fcc', 0.8442) # NOTE: lattice command is different in LJ units
L.region('whole block', 0.0, 10.0, 0, 10, 0, 10)
L.create_box(2, 'whole')
L.region('upper block', 4.9, 10.1, 'EDGE EDGE EDGE EDGE')
L.region('lower block', 0.0, 4.9, 'EDGE EDGE EDGE EDGE')
# fill box with atoms according to lattice positions
L.create_atoms(1, 'region upper')
L.create_atoms(2, 'region lower')
L.mass(1, 1.0)
L.mass(2, 2.0)
L.group('gu', 'type', 1)
L.group('gl', 'type', 2)
L.velocity('gu', 'create 2.0 12345 mom no rot no')
L.velocity('gl', 'create 4.0 54321 mom no rot no')
L.timestep(0.002)
L.pair_style('lj/cut', 2.5)
L.pair_coeff('* *', 1.0, 1.0, 2.5)
L.fix('f1 all nve')
#L.dump('d1 all image 500 snap-03.*.jpg type type')
L.thermo(50)
L.run(500)
def setUp(self):
"""create 3d rocksalt-like structure"""
L = PyLammps()
L.units('real') # kcal/mol, Angstrom, picoseconds
L.atom_style('charge') # atomic + charge
# lattice for Na+ ions and box
L.lattice('fcc', 6.0, 'origin', 0.0, 0.0, 0.0)
L.region('r1', 'block', -3, 3,-3, 3,-3, 3)
L.create_box(2, 'r1')
# fill box with Na+ ions according to lattice positions
L.create_atoms(1, 'box')
# new lattice for Cl- ions shifted by half box diagonal
L.lattice('fcc', 6.0, 'origin', 0.5, 0.5, 0.5)
L.create_atoms(2, 'box')
L.mass(1, 22.989770)
L.mass(2, 35.453)
L.set('type', 1, 'charge', 1.0)
L.set('type', 2, 'charge', -1.0)
L.group('na type', 1)
L.group('cl type', 2)
L.velocity('all create', 800.0, 12345, 'mom no rot no')
L.timestep(0.001)
self.L = L
def data(i):
lmp1 = lammps()
polymer = PyLammps(ptr=lmp1)
x = 60
y = 30
z = 30
t = 1
polymer.units("lj")
polymer.dimension(3)
polymer.atom_style("bond")
polymer.bond_style("harmonic")
polymer.pair_style("lj/cut", 3)
polymer.read_data("data.polymer")
polymer.region("void cylinder x", 15, 15, 2, 29, 31)
polymer.pair_coeff(1, 2, 2.5, 3)
polymer.pair_coeff(1, 3, 2.5, 1.12)
polymer.pair_coeff(2, 3, 2.5, 1.12)
polymer.velocity("all create", t, 97287)
polymer.group("polymer type", 1, 2)
polymer.group("first type", 1)
polymer.region("box block", 0, x, 0, y, 0, z)
polymer.region("spherein sphere", 29, 15, 15, 2)
polymer.region("boxin block", 27, 29, 13, 17, 13, 17)
polymer.region("hemiin intersect", 2, "boxin spherein")
x0 = polymer.atoms[0].position[0]
y0 = polymer.atoms[0].position[1]
z0 = polymer.atoms[0].position[2]
r = lambda x0, y0, z0: np.sqrt((x0 - 29)**2 + (y0 - 15)**2 + (z0 - 15)**2)
fx = lambda x0, y0, z0: 5 * (x0 - 29) / r(x0, y0, z0)
fy = lambda x0, y0, z0: 5 * (y0 - 15) / r(x0, y0, z0)
fz = lambda x0, y0, z0: 5 * (z0 - 15) / r(x0, y0, z0)
polymer.fix(1, "polymer nve")
polymer.fix(2, "polymer langevin", t, t, 1.5,
np.random.randint(2, high=200000))
polymer.fix(3, "polymer spring tether", 10, i, "NULL NULL", 0)
polymer.timestep(0.01)
polymer.compute("com polymer com")
polymer.variable("ftotal equal fcm(polymer,x)")
polymer.variable("c equal c_com[1]")
polymer.thermo_style("custom v_ftotal v_c")
polymer.thermo(1)
polymer.run(500000)
l = polymer.runs[0][0][1][20000:] + [i]
u = [np.mean(polymer.runs[0][0][0][20000:]), i]
np.savetxt("trial%dmean.txt" % i, u)
np.savetxt("trial%dall.txt" % i, l)
return u
L.lattice("fcc", latticeconst)
L.create_box(
3, "simregion"
) # create box containing 3 elements over full simulation region
#L.mass(1,196.96655) # molecular weight in g/mol Au
#L.mass(2,58.6934) # Ni
L.mass(3, 12.011) # C
L.create_atoms(1, "region",
"cluster") # fill cluster region with atoms of type 1
L.create_atoms(3, "random", nPartsub, 4723738,
"subst") # fill substrate region with atoms of type 3
L.group("substinteggr", "region", "substinteg")
L.group("clusterregiongr", "region", "cluster")
L.group("allintegrategr", "region", "allintegr")
L.set("region", "cluster", "type/fraction", 2, xNi, 1234)
L.group("clustergr", "type", 1, 2)
# mit Zhou-Potential:
L.pair_style("hybrid", "eam/alloy", "lj/cut", 10.0, "tersoff")
L.pair_coeff("* * eam/alloy NiAu_Zhou.eam.alloy Au Ni NULL")
L.pair_coeff(1, 3, "lj/cut", epsAuC, sigAuC, 10.0)
L.pair_coeff(2, 3, "lj/cut", epsNiC, sigNiC, 10.0)
L.pair_coeff("* *", "tersoff", "SiC.tersoff", "NULL NULL C")
# mit Ralf Meyers Potential:
class PythonPyLammps(unittest.TestCase):
def setUp(self):
machine = None
if 'LAMMPS_MACHINE_NAME' in os.environ:
machine = os.environ['LAMMPS_MACHINE_NAME']
self.pylmp = PyLammps(
name=machine,
cmdargs=['-nocite', '-log', 'none', '-echo', 'screen'])
self.pylmp.units("lj")
self.pylmp.atom_style("atomic")
self.pylmp.atom_modify("map array")
if 'LAMMPS_CMAKE_CACHE' in os.environ:
self.cmake_cache = {}
with open(os.environ['LAMMPS_CMAKE_CACHE'], 'r') as f:
for line in f:
line = line.strip()
if not line or line.startswith('#') or line.startswith(
'//'):
continue
parts = line.split('=')
key, value_type = parts[0].split(':')
if len(parts) > 1:
value = parts[1]
if value_type == "BOOL":
value = (value.upper() == "ON")
else:
value = None
self.cmake_cache[key] = value
def tearDown(self):
self.pylmp.close()
del self.pylmp
def test_version(self):
self.assertGreaterEqual(self.pylmp.version(), 20200824)
def test_create_atoms(self):
self.pylmp.region("box block", 0, 2, 0, 2, 0, 2)
self.pylmp.create_box(1, "box")
x = [1.0, 1.0, 1.0, 1.0, 1.0, 1.5]
types = [1, 1]
self.assertEqual(
self.pylmp.lmp.create_atoms(2, id=None, type=types, x=x), 2)
self.assertEqual(self.pylmp.system.natoms, 2)
self.assertEqual(len(self.pylmp.atoms), 2)
numpy.testing.assert_array_equal(self.pylmp.atoms[0].position,
tuple(x[0:3]))
numpy.testing.assert_array_equal(self.pylmp.atoms[1].position,
tuple(x[3:6]))
self.assertEqual(self.pylmp.last_run, None)
def test_write_script(self):
outfile = 'in.test_write_script'
self.pylmp.write_script(outfile)
self.assertTrue(os.path.exists(outfile))
os.remove(outfile)
def test_runs(self):
self.pylmp.lattice("fcc", 0.8442),
self.pylmp.region("box block", 0, 4, 0, 4, 0, 4)
self.pylmp.create_box(1, "box")
self.pylmp.create_atoms(1, "box")
self.pylmp.mass(1, 1.0)
self.pylmp.velocity("all create", 1.44, 87287, "loop geom")
self.pylmp.pair_style("lj/cut", 2.5)
self.pylmp.pair_coeff(1, 1, 1.0, 1.0, 2.5)
self.pylmp.neighbor(0.3, "bin")
self.pylmp.neigh_modify("delay 0 every 20 check no")
self.pylmp.fix("1 all nve")
self.pylmp.variable("fx atom fx")
self.pylmp.run(10)
self.assertEqual(len(self.pylmp.runs), 1)
self.assertEqual(self.pylmp.last_run, self.pylmp.runs[0])
self.assertEqual(len(self.pylmp.last_run.thermo.Step), 2)
self.assertEqual(len(self.pylmp.last_run.thermo.Temp), 2)
self.assertEqual(len(self.pylmp.last_run.thermo.E_pair), 2)
self.assertEqual(len(self.pylmp.last_run.thermo.E_mol), 2)
self.assertEqual(len(self.pylmp.last_run.thermo.TotEng), 2)
self.assertEqual(len(self.pylmp.last_run.thermo.Press), 2)
def test_info_queries(self):
self.pylmp.lattice("fcc", 0.8442),
self.pylmp.region("box block", 0, 4, 0, 4, 0, 4)
self.pylmp.create_box(1, "box")
self.pylmp.variable("a equal 10.0")
self.pylmp.variable("b string value")
self.assertEqual(self.pylmp.variables['a'].value, 10.0)
self.assertEqual(self.pylmp.variables['b'].value, 'value')
self.assertEqual(len(self.pylmp.variables), 2)
self.assertEqual(self.pylmp.system.units, 'lj')
self.assertEqual(self.pylmp.system.atom_style, 'atomic')
self.assertEqual(self.pylmp.system.ntypes, 1)
self.assertEqual(self.pylmp.system.natoms, 0)
self.assertEqual(self.pylmp.communication.comm_style, 'brick')
self.assertEqual(self.pylmp.communication.comm_layout, 'uniform')
self.assertEqual(self.pylmp.communication.nprocs, 1)
self.assertEqual(len(self.pylmp.computes), 3)
self.assertEqual(self.pylmp.computes[0]['name'], 'thermo_temp')
self.assertEqual(self.pylmp.computes[0]['style'], 'temp')
self.assertEqual(self.pylmp.computes[0]['group'], 'all')
self.assertEqual(self.pylmp.computes[1]['name'], 'thermo_press')
self.assertEqual(self.pylmp.computes[1]['style'], 'pressure')
self.assertEqual(self.pylmp.computes[1]['group'], 'all')
self.assertEqual(self.pylmp.computes[2]['name'], 'thermo_pe')
self.assertEqual(self.pylmp.computes[2]['style'], 'pe')
self.assertEqual(self.pylmp.computes[2]['group'], 'all')
self.assertEqual(len(self.pylmp.dumps), 0)
self.pylmp.fix('one', 'all', 'nve')
self.assertEqual(len(self.pylmp.fixes), 1)
self.assertEqual(self.pylmp.fixes[0]['name'], 'one')
self.assertEqual(self.pylmp.fixes[0]['style'], 'nve')
self.assertEqual(self.pylmp.fixes[0]['group'], 'all')
self.pylmp.group('none', 'empty')
self.assertEqual(len(self.pylmp.groups), 2)
py_lmp.neigh_modify("every 1 delay 1")
py_lmp.timestep(run_args.dt)
# THERMALIZE INITIAL CONFIGURATION
simulation.deactivate_state(0, vx_eps=5.0)
py_lmp.run(1000)
simulation.activate_state(0)
py_lmp.reset_timestep(0)
# GROUPS & COMPUTES
if hasattr(run_args, 'label_micelles'):
micelle_group = 'sol_tips'
sol_tip_bead_type = model.state_structures[0][0][-1]
py_lmp.variable(micelle_group, 'atom',
'"type == {:d}"'.format(sol_tip_bead_type))
py_lmp.group(micelle_group, 'dynamic', simulation.rods_group, 'var',
micelle_group, 'every', out_freq)
micelle_compute = "micelle_ID"
if hasattr(run_args, 'micelle_cutoff'):
micelle_cutoff = run_args.micelle_cutoff
else:
SS_tip_int_key = model.eps[(sol_tip_bead_type, sol_tip_bead_type)][1]
SS_tip_int_range = model.int_types[SS_tip_int_key][1]
micelle_cutoff = 2 * model.rod_radius + SS_tip_int_range
py_lmp.compute(micelle_compute, micelle_group, 'aggregate/atom',
micelle_cutoff)
# OUTPUT
dump_elems = "id x y z type mol"
try:
dump_elems += " c_" + micelle_compute
except:
]
tip_lipid_contact = 0.5 * membrane.sigma * pow(2, 1. / 6) + model.rod_radius
tip_lipid_cutoff = tip_lipid_contact + run_args.mem_int_range
for tip_type in tip_types:
for mem_bead_type, k in zip(membrane.bead_types, int_factors):
py_lmp.pair_coeff(mem_bead_type, tip_type, k * sol_lipid_eps,
tip_lipid_contact, tip_lipid_cutoff, 'wca')
# ===== RODS ============================================================================
# GROUPS & COMPUTES
if hasattr(run_args, 'label_micelles'):
micelle_group = 'sol_tips'
sol_tip_bead_type = model.state_structures[0][0][-1]
py_lmp.variable(micelle_group, 'atom',
'"type == {:d}"'.format(sol_tip_bead_type))
py_lmp.group(micelle_group, 'dynamic', simulation.rods_group, 'var',
micelle_group, 'every', out_freq)
micelle_compute = "micelle_ID"
if hasattr(run_args, 'micelle_cutoff'):
micelle_cutoff = run_args.micelle_cutoff
else:
SS_tip_int_key = model.eps[(sol_tip_bead_type, sol_tip_bead_type)][1]
SS_tip_int_range = model.int_types[SS_tip_int_key][1]
micelle_cutoff = 2 * model.rod_radius + SS_tip_int_range
py_lmp.compute(micelle_compute, micelle_group, 'aggregate/atom',
micelle_cutoff)
#TODO label_fibrils ??
# FIXES & DYNAMICS
thermo_fix = 'thermostat'
py_lmp.fix(thermo_fix, 'all', 'langevin', run_args.temp, run_args.temp,
simulation.deactivate_state(0, vx_eps=5.0)
py_lmp.command('run 10000')
simulation.activate_state(0)
py_lmp.reset_timestep(0)
# GROUPS & COMPUTES
if hasattr(run_args, 'label_fibrils'):
fibril_group = 'beta_patches'
beta_active_patch_types = sorted(filter(lambda t: (t in model.active_bead_types) and\
(t not in model.body_bead_types),
model.state_bead_types[1]))
py_lmp.variable(
fibril_group, 'atom', '"' + '||'.join(
['(type == {:d})'.format(t)
for t in beta_active_patch_types]) + '"')
py_lmp.group(fibril_group, 'dynamic', simulation.rods_group, 'var',
fibril_group, 'every', out_freq)
fibril_compute = "fibril_ID"
if hasattr(run_args, 'fibril_cutoff'):
fibril_cutoff = run_args.fibril_cutoff
else:
fibril_cutoff = 0
i = -1
for t1 in beta_active_patch_types:
i += 1
for t2 in beta_active_patch_types[i:]:
try:
int_key = model.eps[(t1, t2)][1]
except:
continue
int_range = model.int_types[int_key][1]
cutoff = model.bead_radii[t1] + model.bead_radii[
class LammpsKernel(IGMKernel):
def __init__(self, model, cfg, runid):
self.cfg = cfg
self.model = model
self.runid = runid
self.tmp_dir = self.cfg.tmpdir('optimization')
self.randseed = int(self.cfg["optimization/kernel_opts/lammps/seed"])
self.initLammps()
self.setupSimulationBox()
self.setupParticles()
self.setCoordinates()
self.setRadii()
self.setupNeighbor()
def initLammps(self):
"""
setup lammps python interface, log file
"""
if self.cfg["optimization/kernel_opts/lammps/keep_logs"]:
self.Lmp = PyLammps(cmdargs=["-log",os.path.join(self.tmp_dir, self.runid+".log")])
else:
self.Lmp = PyLammps(cmdargs=["-log","none"])
self.Lmp.atom_style("bond")
self.Lmp.boundary('s','s','s')
def setupSimulationBox(self):
"""
setup lammps simulation box
"""
atom_types = 1
bond_types = 0
bond_per_atom = 0
for Res in self.model.restraints:
atom_types += Res.extra_atom_types
bond_types += Res.extra_bond_types
bond_per_atom += Res.extra_bond_per_atom
if res.type == "Envelope":
xx , yy, zz = Res.a*1.2, Res.b*1.2, Res.c*1.2
self.Lmp.region("IGMBOX", "block", -xx, xx, -yy, yy, -zz, zz)
self.Lmp.create_box(1, "IGMBOX", "bond/types", bond_types, "extra/bond/per/atom", bond_per_atom)
def setupParticles(self):
"""
initialize particles with random position
"""
#add user define per-atom property: radius(double)
self.Lmp.fix("UserProperty","all","property/atom","d_radius")
#number of particles
self.nbead = len(self.model.particles)
self.atom_style_index = 1
self.Lmp.create_atoms(1, "random", self.nbead, self.randseed, "IGMBOX")
#set particle mass 1.0
self.Lmp.mass('*', 1.0)
#group particle NORMAL
self.lmp_group_NORMAL = "NORMAL"
self.Lmp.group(self.lmp_group_NORMAL, "type", 1)
#get numpy view of per atom array
self.particle_id = self.Lmp.lmp.numpy.extract_atom_iarray('id', n, 1)
self._coordinates = self.Lmp.lmp.numpy.extract_atom_darray('x', n, 3)
self._radii = self.lmp.lmp.numpy.extract_atom_darray('d_radius', n, 1)
def indexMapping(self):
"""
particle mapping from lammps index to original index
"""
return np.argsort( self.particle_id[:, 0] )
def setCoordinates(self, crd = None):
"""
assign xyz values to lammps
"""
if crd:
self.coordinates[self.indexMapping(), :] = crd[:]
else:
self.coordinates[self.indexMapping(), :] = self.model.particles.coordinates[:]
def setRadii(self, radii = None):
"""
assign radius values to lammps
"""
if radii:
self.radii[self.indexMapping(), :] = radii[:]
else:
self.radii[self.indexMapping(), :] = self.model.particles.radii[:]
self.maxrad = max(self.radii)
def setupNeighbor(self):
"""
setup neighbor list rules
"""
if hasattr(self, "maxrad"):
self.Lmp.neighbor(self.maxrad, 'bin')
else:
raise RuntimeError("Radii not set before setupNeighbor()")
max_neighbor = int(self.cfg["optimization/kernel_opts/lammps/max_neigh"])
self.Lmp.neigh_modify('every',1,'check','yes')
self.Lmp.neigh_modify("one", max_neighbor, 'page', 20*max_neighbor)
def addRestraints(self):
"""
add restraints to lammps one by one
"""
#lammps bond style definition
bond_styles = set()
n = 1
for Res in self.model.restraints:
if hasattr(Res, "bond_style"):
bond_styles.add(Res.bond_style)
#give_bond_id
Res.setBondId(n)
n += 1
if len(bond_styles) == 1:
self.Lmp.bond_style(bond_styles.pop())
elif len(bond_styles) > 1:
cmd = ["bond_style", "hybrid"]
while bond_styles:
cmd.append(bond_styles.pop())
self.Lmp.command(" ".join(cmd))
#define variable for fast communication/avoid input string parsing
self.Lmp.variable("batoms","string","EMPTY")
bond_variable = "batoms"
#loop all restraints and apply lammps code
for Res in self.model.restraints:
Res.Lammps(self.Lmp, runid = self.runid,
tmp_dir = self.tmp_dir,
randseed = self.randseed,
normal_group = self.lmp_group_NORMAL,
bond_variable = bond_variable)