def setUp(self):
self.lamb = 1 # Dipolar coupling constant: mu0*m^2/ (2 * pi * d^3 * K * T)
self.r_cut = 15
# interaction cut-off
self.diameter = 1
# particles diameter
# interaction between point dipoles
self.dipole_dipole = """ float rsq = dot(r_ij, r_ij);
float r_cut = {0};
if (rsq < r_cut*r_cut)
{{
float lambda = {1};
float r = fast::sqrt(rsq);
float r3inv = 1.0 / rsq / r;
vec3<float> t = r_ij / r;
vec3<float> pi_o(1,0,0);
vec3<float> pj_o(1,0,0);
rotmat3<float> Ai(q_i);
rotmat3<float> Aj(q_j);
vec3<float> pi = Ai * pi_o;
vec3<float> pj = Aj * pj_o;
float Udd = (lambda*r3inv/2)*( dot(pi,pj)
- 3 * dot(pi,t) * dot(pj,t));
return Udd;
}}
else
return 0.0f;
""".format(self.r_cut, self.lamb)
self.snapshot = data.make_snapshot(N=2,
box=data.boxdim(L=2 * self.r_cut,
dimensions=3),
particle_types=['A'])
def setUp(self):
lennard_jones = """
float rsq = dot(r_ij, r_ij);
float rcut = alpha_iso[0];
if (rsq <= rcut*rcut)
{{
float sigma = alpha_iso[1];
float eps = alpha_iso[2];
float sigmasq = sigma*sigma;
float rsqinv = sigmasq / rsq;
float r6inv = rsqinv*rsqinv*rsqinv;
return 4.0f*eps*r6inv*(r6inv-1.0f);
}}
else
{{
return 0.0f;
}}
"""
self.dist = 2.0
# distance between test particles
snapshot = data.make_snapshot(N=2,
box=data.boxdim(L=10, dimensions=3),
particle_types=['A'])
snapshot.particles.position[0, :] = (0, 0, 0)
snapshot.particles.position[1, :] = (self.dist, 0, 0)
system = init.read_snapshot(snapshot)
mc = hpmc.integrate.sphere(seed=1, d=0)
mc.shape_param.set('A', diameter=0)
self.patch = jit.patch.user(mc=mc,
r_cut=2.5,
array_size=3,
code=lennard_jones)
self.logger = analyze.log(filename=None,
quantities=["hpmc_patch_energy"],
period=1)
def initialize_snap(syst, params={}):
syst["np"] = sum(
syst["len_polymers"]) * (1 + syst["excess_DNA"]) + syst["ndiff"]
syst["nbond"] = sum(syst["len_polymers"]) - len(syst["len_polymers"])
if syst["cohesin_real"]:
syst["np"] += syst["n_cohesin"] * syst["particule_per_cohesin"]
syst["nbond"] += syst["n_cohesin"] * syst["particule_per_cohesin"]
syst["Rf"] = (sum(syst["len_polymers"]) * 0.5**3 / syst['density'])**0.33
print("Radius of the cell", syst["Rf"])
R = syst["Rf"] + 1
snapshot = data.make_snapshot(N=syst["np"],
box=data.boxdim(L=2 * R),
bond_types=['polymer'])
syst["bond_list"] = ['DNA', 'cohesin', "fFactor", "weak"]
syst["plist"] = [
"DNA", "uDNA", "pDNA", "fFactor", 'cohesine', "rDNA", "fDNA", "tDNA"
]
# uDNA unreplicated DNA
# rDNA replicated DNA
# fDNA freshly replicated DNA
# tDNA template replicated DNA
return snapshot, syst
def setUp(self):
snap = data.make_snapshot(3, data.boxdim(Lx = 3.5, Ly = 1.5, Lz = 1.5))
#Setup a set of positions which we can easily see the overlaps for
snap.particles.position[0] = [-.9, 0.0, 0.0]
snap.particles.position[1] = [0.0, 0.0, 0.0]
snap.particles.position[2] = [1.0, 0.25, 0.0]
self.system = init.read_snapshot(snap)
self.mc = hpmc.integrate.sphere(seed=123)
def setUp(self):
snap = data.make_snapshot(3, data.boxdim(Lx=3.5, Ly=1.5, Lz=1.5))
#Setup a set of positions which we can easily see the overlaps for
snap.particles.position[0] = [-.9, 0.0, 0.0]
snap.particles.position[1] = [0.0, 0.0, 0.0]
snap.particles.position[2] = [1.0, 0.25, 0.0]
self.system = init.read_snapshot(snap)
self.mc = hpmc.integrate.sphere(seed=123)
def setUp(self):
# square well attraction on constituent spheres
square_well = """float rsq = dot(r_ij, r_ij);
float r_cut = alpha_union[0];
if (rsq < r_cut*r_cut)
return alpha_union[1];
else
return 0.0f;
"""
# soft repulsion between centers of unions
soft_repulsion = """float rsq = dot(r_ij, r_ij);
float r_cut = alpha_iso[0];
if (rsq < r_cut*r_cut)
return alpha_iso[1];
else
return 0.0f;
"""
diameter = 1.0
snapshot = data.make_snapshot(N=2,
box=data.boxdim(L=10, dimensions=3),
particle_types=['A'])
snapshot.particles.position[0, :] = (0, 0, 0)
snapshot.particles.position[1, :] = (diameter, 0, 0)
system = init.read_snapshot(snapshot)
mc = hpmc.integrate.sphere_union(d=0, a=0, seed=1)
mc.shape_param.set('A',
diameters=[diameter] * 2,
centers=[(0, 0, -diameter / 2),
(0, 0, diameter / 2)],
overlap=[0] * 2)
self.patch = jit.patch.user_union(mc=mc, r_cut=2.5, array_size=2, r_cut_iso=2.5, array_size_iso=2, \
code=square_well, code_iso=soft_repulsion)
self.patch.set_params('A',
positions=[(0, 0, -diameter / 2),
(0, 0, diameter / 2)],
typeids=[0, 0])
self.logger = analyze.log(filename=None,
quantities=["hpmc_patch_energy"],
period=1)
def to_hoomd_snapshot(self, snapshot=None):
"Copy this frame to a HOOMD-blue snapshot."
self.load()
if snapshot is None:
try:
from hoomd import data
except ImportError:
try:
# Try importing from hoomd 1.x
from hoomd_script import data
except ImportError:
raise ImportError('hoomd')
box = data.boxdim(
Lx=self.box.Lx,
Ly=self.box.Ly,
Lz=self.box.Lz,
xy=self.box.xy,
xz=self.box.xz,
yz=self.box.yz,
dimensions=self.box.dimensions,
)
snapshot = data.make_snapshot(
N=len(self),
box=box,
particle_types=self.types,
)
np.copyto(
snapshot.particles.typeid,
np.array(self.typeid, dtype=snapshot.particles.typeid.dtype))
for prop in PARTICLE_PROPERTIES:
try:
np.copyto(getattr(snapshot.particles, prop),
getattr(self, prop))
except AttributeError:
pass
return snapshot
def create_empty(**kwargs):
snap = data.make_snapshot(**kwargs);
return init.read_snapshot(snap);
def test_access(self):
N = 2
L = 10
context.initialize()
self.snapshot = data.make_snapshot(N=N,
box=data.boxdim(L=L, dimensions=2),
particle_types=['A'])
# sphere
diam = 1.125
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.sphere(seed=2398, d=0.0)
self.mc.shape_param.set('A', diameter=diam)
self.assertAlmostEqual(self.mc.shape_param['A'].diameter, diam)
del self.mc
del self.system
context.initialize()
# ellipsoid
a = 1.125
b = 0.238
c = 2.25
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.ellipsoid(seed=2398, d=0.0)
self.mc.shape_param.set('A', a=a, b=b, c=c)
self.assertAlmostEqual(self.mc.shape_param['A'].a, a)
self.assertAlmostEqual(self.mc.shape_param['A'].b, b)
self.assertAlmostEqual(self.mc.shape_param['A'].c, c)
del self.mc
del self.system
context.initialize()
# convex_polygon
v = [(-1, -1), (1, -1), (1, 1), (-1, 1)]
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.convex_polygon(seed=2398, d=0.1, a=0.1)
self.mc.shape_param.set('A', vertices=v)
diff = (np.array(v) -
np.array(self.mc.shape_param['A'].vertices)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
del self.mc
del self.system
context.initialize()
# convex_spheropolygon
v = [(-1, -1), (1, -1), (1, 1), (-1, 1)]
r = 0.1234
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.convex_spheropolygon(seed=2398, d=0.1, a=0.1)
self.mc.shape_param.set('A', vertices=v, sweep_radius=r)
diff = (np.array(v) -
np.array(self.mc.shape_param['A'].vertices)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
self.assertAlmostEqual(self.mc.shape_param['A'].sweep_radius, r)
del self.mc
del self.system
context.initialize()
#simple_polygon
v = [(-1, -1), (1, -1), (1, 1), (-1, 1)]
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.simple_polygon(seed=2398, d=0.1, a=0.1)
self.mc.shape_param.set('A', vertices=v)
diff = (np.array(v) -
np.array(self.mc.shape_param['A'].vertices)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
del self.mc
del self.system
context.initialize()
# polyhedron
import math
v = [(-0.5, -0.5, 0), (-0.5, 0.5, 0), (0.5, -0.5, 0), (0.5, 0.5, 0),
(0, 0, 1.0 / math.sqrt(2)), (0, 0, -1.0 / math.sqrt(2))]
f = [(0, 4, 1), (1, 4, 2), (2, 4, 3), (3, 4, 0), (0, 5, 1), (1, 5, 2),
(2, 5, 3), (3, 5, 0)]
r = 0.0
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.polyhedron(seed=10)
self.mc.shape_param.set('A', vertices=v, faces=f, sweep_radius=r)
diff = (np.array(v) -
np.array(self.mc.shape_param['A'].vertices)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
diff = (np.array(f) -
np.array(self.mc.shape_param['A'].faces)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
self.assertAlmostEqual(self.mc.shape_param['A'].sweep_radius, r)
del self.mc
del self.system
context.initialize()
# convex_polyhedron
v = [(1, 1, 1), (1, -1, 1), (-1, -1, 1), (-1, 1, 1), (1, 1, -1),
(1, -1, -1), (-1, -1, -1), (-1, 1, -1)]
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.convex_polyhedron(seed=2398, d=0.1, a=0.1)
self.mc.shape_param.set('A', vertices=v)
diff = (np.array(v) -
np.array(self.mc.shape_param['A'].vertices)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
del self.mc
del self.system
context.initialize()
# convex_spheropolyhedron
v = [(1, 1, 1), (1, -1, 1), (-1, -1, 1), (-1, 1, 1), (1, 1, -1),
(1, -1, -1), (-1, -1, -1), (-1, 1, -1)]
r = 0.1234
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.convex_spheropolyhedron(seed=2398,
d=0.1,
a=0.1)
self.mc.shape_param.set('A', vertices=v, sweep_radius=r)
diff = (np.array(v) -
np.array(self.mc.shape_param['A'].vertices)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
self.assertAlmostEqual(self.mc.shape_param['A'].sweep_radius, r)
del self.mc
del self.system
context.initialize()
# faceted_sphere
v = [(-1, -1, -1), (-1, -1, 1), (-1, 1, -1), (-1, 1, 1), (1, -1, -1),
(1, -1, 1), (1, 1, -1), (1, 1, 1)]
offs = [-1] * 6
norms = [(-1, 0, 0), (1, 0, 0), (
0,
1,
0,
), (0, -1, 0), (0, 0, 1), (0, 0, -1)]
diam = 2
orig = (0, 0, 0)
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.faceted_sphere(seed=10)
self.mc.shape_param.set('A',
normals=norms,
offsets=offs,
vertices=v,
diameter=diam,
origin=orig)
diff = (np.array(v) -
np.array(self.mc.shape_param['A'].vertices)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
diff = (np.array(offs) -
np.array(self.mc.shape_param['A'].offsets)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
diff = (np.array(norms) -
np.array(self.mc.shape_param['A'].normals)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
diff = (np.array(orig) -
np.array(self.mc.shape_param['A'].origin)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
self.assertAlmostEqual(self.mc.shape_param['A'].diameter, diam)
del self.mc
del self.system
context.initialize()
# sphinx
# GPU Sphinx is not built on most the time
if not hoomd.context.current.device.cpp_exec_conf.isCUDAEnabled():
cent = [(0, 0, 0), (0, 0, 1.15), (0, 0, -1.15)]
diams = [2, -2.2, -2.2]
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.sphinx(seed=10)
self.mc.shape_param.set('A', diameters=diams, centers=cent)
diff = (np.array(cent) -
np.array(self.mc.shape_param['A'].centers)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
diff = (np.array(diams) -
np.array(self.mc.shape_param['A'].diameters)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
del self.mc
del self.system
context.initialize()
# sphere_union
cent = [(0, 0, 0), (0, 0, 1.15), (0, 0, -1.15)]
diams = [2, 2.2, 1.75]
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.sphere_union(seed=10)
self.mc.shape_param.set('A', diameters=diams, centers=cent)
diff = (np.array(cent) -
np.array(self.mc.shape_param['A'].centers)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
for i, m in enumerate(self.mc.shape_param['A'].members):
self.assertAlmostEqual(m.diameter, diams[i])
del self.mc
del self.system
del self.snapshot
context.initialize()
def setUp(self):
snap = data.make_snapshot(N=0,box=data.boxdim(Lx = 10, Ly = 10, Lz = 10))
self.system = init.read_snapshot(snap)
self.mc = hpmc.integrate.convex_polyhedron(seed=123)
def simulate(traj_filename):
with open(traj_filename, "r") as f:
traj = json.load(f)
seed = traj["seed"]
len_chrom = traj["len_chrom"]
Cent = traj["Cent"]
p_ribo = traj["p_ribo"]
R = traj["R"]
micron = traj["micron"]
data_folder = traj["data_folder"]
# Diffusing elements
N_diffu = traj["N_diffu"]
cut_off_inte = traj["cut_off_inte"]
p_inte = traj["p_inte"]
dt = traj["dt"]
p_origins = traj["p_origins"]
# Yeast case
spb = traj["spb"]
nucleole = traj["nucleole"]
telomere = traj["telomere"]
microtubule_length = traj["microtubule_length"] * micron
diameter_nuc = traj["diameter_nuc"] * micron
special_start = traj["special_start"]
Activ_Origins = traj["Activ_Origins"]
visu = traj["visu"]
dump_hic = traj["dump_hic"]
# Scenari
diff_alone = traj["diff_alone"]
diff_bind_when_free = traj["diff_bind_when_free"]
diff_bind_when_on_DNA = traj["diff_bind_when_on_DNA"]
replicate_DNA = traj["replicate_DNA"]
np.random.seed(seed)
hoomd.context.initialize("--mode=cpu")
if diff_alone:
# Check
assert (diff_bind_when_free is False)
assert (diff_bind_when_on_DNA is False)
# End of parameter
##########################################
#########################################
# Define polymer bonding and positions
Np = len(len_chrom)
assert (len(len_chrom) == len(Cent) == len(p_ribo))
if special_start:
Sim = create_init_conf_yeast(len_chrom=len_chrom,
dist_centro=Cent,
p_ribo=p_ribo,
Radius=R,
Mt=microtubule_length)
else:
Sim = []
spbp = 0 if not spb else 1
Total_particle = sum(len_chrom) + N_diffu * 2 + spbp
list_nuc = [
list(range(start, start + size)) if size != 0 else []
for start, size in p_ribo
]
# print(list_nuc)
# exit()
snapshot = data.make_snapshot(N=Total_particle,
box=data.boxdim(L=2 * R),
bond_types=['polymer'])
spbb = Np if spb else 0
if visu:
spbb = 0
bond_diffu = 0
if diff_bind_when_free:
bond_diffu = N_diffu
snapshot.bonds.resize(sum(len_chrom) - len(len_chrom) + bond_diffu + spbb)
bond_list = ['Mono_Mono', 'Diff_Diff', 'Mono_Diff']
if spb:
bond_list += ["Spb_Cen"]
if nucleole:
bond_list += ["Mono_Nuc", "Nuc_Nuc"]
snapshot.bonds.types = bond_list
plist = ['Mono', 'Ori', 'Diff', 'A_Ori', 'P_Ori', 'S_Diff', 'F_Diff']
if spb:
plist.append("Spb")
if nucleole:
plist += ['Nuc', 'A_Nuc', 'P_Nuc']
if telomere:
plist += ["Telo"]
snapshot.particles.types = plist
offset_bond = 0
offset_particle = 0
lPolymers = []
################################################
# Polymer chains
Cen_pos = []
for i in range(Np):
found_cen = False
npp = len_chrom[i] # Number of particles
# Position of origin of replication
pos_origins = p_origins[i]
if Sim == []:
initp = 2 * np.random.rand(3) - 1
else:
# print(i)
initp = Sim.molecules[i].coords[0]
for p in range(npp - 1):
inuc = 0
if nucleole:
if p in list_nuc[i]:
inuc += 1
if p + 1 in list_nuc[i]:
inuc += 1
snapshot.bonds.group[offset_bond + p] = [
offset_particle + p, offset_particle + p + 1
]
if inuc == 0:
snapshot.bonds.typeid[offset_bond + p] = bond_list.index(
'Mono_Mono') # polymer_A
if inuc == 1:
snapshot.bonds.typeid[offset_bond + p] = bond_list.index(
'Mono_Nuc') # polymer_A
if inuc == 2:
snapshot.bonds.typeid[offset_bond + p] = bond_list.index(
'Nuc_Nuc') # polymer_A
offset_bond += npp - 1
for p in range(npp):
# print(offset_bond, offset_bond + p)
if Sim == []:
new = 2 * (2 * np.random.rand(3) - 1)
while linalg.norm(initp + new) > R - 1:
new = 2 * (2 * np.random.rand(3) - 1)
initp += new
else:
initp = Sim.molecules[i].coords[p]
snapshot.particles.position[offset_particle + p] = initp
if p in pos_origins:
snapshot.particles.typeid[offset_particle + p] = plist.index(
'Ori') # Ori
else:
snapshot.particles.typeid[offset_particle + p] = plist.index(
'Mono') # A
if spb and p == Cent[i]:
Cen_pos.append(offset_particle + p)
found_cen = True
if nucleole and p in list_nuc[i]:
snapshot.particles.typeid[offset_particle +
p] = plist.index('Nuc')
if telomere and (p == 0 or p == npp - 1):
snapshot.particles.typeid[offset_particle +
p] = plist.index('Telo')
lPolymers.append(
Polymer(i, offset_particle, offset_particle + npp - 1,
[po + offset_particle for po in pos_origins]))
offset_particle += npp
assert (found_cen == spb)
phic = 0
if dump_hic:
phic = 0 + offset_particle - 1
###################################################
# SPD
if spb:
tag_spb = 0 + offset_particle
# print(tag_spb)
# print(snapshot.particles[offset_particle])
snapshot.particles.position[offset_particle] = [-R + 0.1, 0, 0]
snapshot.particles.typeid[offset_particle] = plist.index('Spb')
offset_particle += 1
if not visu:
for i in range(Np):
# print(offset_particle - 1, Cen_pos[i])
snapshot.bonds.group[offset_bond] = [
offset_particle - 1, Cen_pos[i]
]
snapshot.bonds.typeid[offset_bond] = bond_list.index(
'Spb_Cen') # polymer_A
offset_bond += 1
############################################################
# Diffusing elements
# Defining useful classes
# Defining particles and bonds for the simulation
for i in range(N_diffu):
npp = 2 # Number of particles
initp = (R - 2) * (2 * np.random.rand(3) - 1)
while linalg.norm(initp) > R - 1:
initp = (R - 2) * (2 * np.random.rand(3) - 1)
if diff_bind_when_free:
for p in range(npp - 1):
snapshot.bonds.group[offset_bond + p] = [
offset_particle + p, offset_particle + p + 1
]
snapshot.bonds.typeid[offset_bond + p] = bond_list.index(
'Diff_Diff') # Diff_Diff
offset_bond += npp - 1
for p in range(npp):
# print(offset_bond, offset_bond + p)
if diff_bind_when_free:
new = 2 * (2 * np.random.rand(3) - 1)
while linalg.norm(initp + new) > R - 1:
new = 2 * (2 * np.random.rand(3) - 1)
# print(initp,new,R,linalg.norm(initp + new))
# exit()
initp += new
else:
initp = (R - 1) * (2 * np.random.rand(3) - 1)
snapshot.particles.position[offset_particle + p] = initp
snapshot.particles.typeid[offset_particle + p] = plist.index(
"Diff") # Diffu
offset_particle += npp
# Load the configuration
for i, p in enumerate(snapshot.bonds.group):
if p[0] == p[1]:
print(i, p)
system = init.read_snapshot(snapshot)
for i, p in enumerate(system.particles):
# print(p)
# exit()
assert p.tag == i
for i, b in enumerate(system.bonds):
if b.a == b.b:
print(b.a, b.b)
raise
# print(p)
# exit()
assert b.tag == i
###############################################
###############################################
# Defining force field:
harmonic = md.bond.harmonic()
harmonic.bond_coeff.set(bond_list, k=330.0, r0=1)
harmonic.bond_coeff.set('Mono_Diff', k=10.0, r0=1)
if spb:
harmonic.bond_coeff.set('Spb_Cen', k=1000.0, r0=microtubule_length)
if nucleole:
harmonic.bond_coeff.set('Nuc_Nuc', k=330, r0=diameter_nuc)
harmonic.bond_coeff.set('Mono_Nuc',
k=330,
r0=diameter_nuc / 2. + 1. / 2)
nl = md.nlist.tree(r_buff=0.4, check_period=1)
# Potential for warmup
gauss = md.pair.gauss(r_cut=3.0, nlist=nl)
gauss.pair_coeff.set(plist, plist, epsilon=1.0, sigma=1.0)
if nucleole:
for ip1, p1 in enumerate(plist):
for p2 in plist[ip1:]:
inuc = 0
if "Nuc" in p1:
inuc += 1
if "Nuc" in p2:
inuc += 1
if inuc == 1:
gauss.pair_coeff.set(p1,
p2,
epsilon=.5,
sigma=0.5 + diameter_nuc / 2.,
r_cut=(0.5 + diameter_nuc / 2.) * 3)
if inuc == 2:
gauss.pair_coeff.set(p1,
p2,
epsilon=1.0,
sigma=diameter_nuc,
r_cut=3 * diameter_nuc)
# gauss.pair_coeff.set('A', 'A', epsilon=1.0, sigma=1.0)
# gauss.pair_coeff.set('A', 'A', epsilon=1.0, sigma=1.0)
# Spherical confinement
sphere = md.wall.group()
sphere.add_sphere(r=R, origin=(0.0, 0.0, 0.0), inside=True)
wall_force_slj = md.wall.slj(sphere, r_cut=3.0)
wall_force_slj.force_coeff.set(plist, epsilon=1.0, sigma=1.0, r_cut=1.12)
if nucleole:
wall_force_slj.force_coeff.set('Nuc',
epsilon=1.0,
sigma=diameter_nuc,
r_cut=diameter_nuc * 1.12)
if telomere:
wall_force_slj.force_coeff.set(plist, epsilon=2.0, sigma=1.5, r_cut=3)
# Group;
all_beads = group.all()
if spb:
Spb_g = group.tag_list(name="Spb", tags=[tag_spb])
pspb = [p.position for p in Spb_g]
print(pspb)
all_move = group.difference(name="move", a=all_beads, b=Spb_g)
else:
all_move = all_beads
# Log
logger = analyze.log(filename=data_folder + 'mylog.log',
period=1000,
quantities=[
'temperature', 'potential_energy',
'kinetic_energy', 'volume', 'pressure'
],
overwrite=True)
# Warmup
converged = False
dt = 0.005
while not converged and not visu:
try:
method = md.integrate.mode_minimize_fire(group=all_move, dt=dt)
while not (method.has_converged()):
if spb:
pspb = [p.position for p in Spb_g]
"""
print(pspb)
for cen in Cen_pos:
cent_tmp = system.particles[cen]
print(cent_tmp.position)
print(linalg.norm(np.array(pspb[0])-np.array(cent_tmp.position)))
print(R * microtubule_length)
"""
# exit()
hoomd.run(100)
converged = True
except:
converged = False
dt /= 2.
print(dt)
# Restore positions
for ip, p in enumerate(snapshot.particles.position):
system.particles[ip].position = p
"""
gauss.disable()
slj=md.pair.slj(r_cut=2, nlist=nl)
slj.pair_coeff.set(plist,plist,sigma=1,epsilon=1,r_cut=1.12)
print("Second minimizing")
method=md.integrate.mode_minimize_fire(group=all_beads,dt=0.05)
while not(method.has_converged()):
hoomd.run(100)
"""
# hoomd.run(1000000)
# method.disable()
# Dumping
if visu:
xml = deprecated.dump.xml(filename=data_folder + "atoms.hoomdxml",
period=None,
group=all_beads,
vis=True)
exit()
# gsd = dump.gsd(filename=data_folder + "atoms.gsd",period=None,group=all_beads)
dcd = dump.dcd(filename=data_folder + 'poly.dcd',
period=100,
overwrite=True)
# Dynamics
t0 = time.time()
md.integrate.mode_standard(dt=0.01)
method = md.integrate.langevin(group=all_move, kT=1, seed=seed)
snp = system # .take_snapshot()
def Change_type(typep, particle_list, snp, msg=""):
# print(particle_list)
for p in particle_list:
snp.particles[p].type = typep
if particle_list != [] and msg != "":
print(msg)
def Bind(typeb, bondlist, snp):
btags = []
for b1, b2 in bondlist:
btags.append(snp.bonds.add(typeb, b1, b2))
return btags
def Release(btags, snp):
for bt in btags:
snp.bonds.remove(bt)
def AddParticle(position, type):
snp.particles.add(type)
snp.particles[-1].position = position
def Shift(bonds, snp):
for tag, new in bonds:
b = snp.bonds.get(tag)
btype = "" + b.type
fork = b.b + 0
snp.bonds.remove(tag)
# print(b.type)
snp.bonds.add(btype, new, fork)
# print(new,b)
# print(dir(snp.bonds))
# b.a = new
group_diffu = group.type(name="Diff", type='Diff')
if Activ_Origins != []:
group_origin = group.type(name="Activ_Ori", type=Activ_Origins[0])
if len(Activ_Origins) > 1:
for t in Activ_Origins[1:]:
group_origin = group.union(name="Activ_origin",
a=group_origin,
b=group.type(name="tmp", type=t))
r_hic = []
if dump_hic:
group_hic = group.tags(name="hic", tag_min=0, tag_max=phic)
# nl.tune(warmup=1,steps=1000)
for i in range(100):
# Chek that the microtubule length is correct
if spb:
for cen in Cen_pos:
cent_tmp = system.particles[cen]
# print(cent_tmp.position)
d = linalg.norm(
np.array(pspb[0]) - np.array(cent_tmp.position))
if d > 2 * microtubule_length:
print("MT too long", d)
exit()
# Dump the Hi-Cs
# system.restore_snapshot(snp)
hoomd.run(1000)
if dump_hic:
ph = np.array([p.position for p in group_hic])
D = cdist(ph, ph)
D[D < 2] = 1
D[D >= 2] = 0
np.fill_diagonal(D, 0)
if r_hic != []:
r_hic += D
else:
r_hic = D
np.save(data_folder + "/hic", r_hic)
# snp = system.take_snapshot()
# update the position of the monomer by updating bonds
for iP, P in enumerate(lPolymers):
verbose = False
# if iP == 9:
# verbose = True
bind_diff, diff_diff, shifted_bonds, \
passivated_origin, to_release, alone = P.increment_time(
1, verbose)
Change_type('P_Ori', passivated_origin, snp,
msg="") # Passivated origin
if not diff_alone:
Shift(shifted_bonds, snp)
# Bond tags to release (Alone particle)
Release(to_release, snp)
if diff_bind_when_free:
# Pair of diffu to attach
Bind("Diff_Diff", bind_diff, snp)
# We cannot use the single diff anymore
Change_type("S_Diff", alone, snp)
# Change type for pair of diff diff
Change_type("Diff", diff_diff, snp)
group_diffu.force_update()
group_origin.force_update()
# Update Type because of (Ori to passivated)
# Update group
# Find new interacting particles
# First check if Dimer are close from one origin
p_diffu = np.array([p.position for p in group_diffu])
tag_diffu = [p.tag for p in group_diffu]
p_origin = np.array([p.position for p in group_origin])
tag_origin = [p.tag for p in group_origin]
if tag_diffu != [] and tag_origin != []:
distances = cdist(p_diffu, p_origin)
print(distances.shape)
# Reorder the distances with the dimer tags
Indexes = []
PTags = []
# t0 = time.time()
Btags = []
# Groups Diff-Diff by bond to compute the distances
if diff_bind_when_free:
for b in system.bonds:
if b.type == 'Diff_Diff' and system.particles[
b.a].type == 'Diff':
Indexes.append(tag_diffu.index(b.a))
Indexes.append(tag_diffu.index(b.b))
Btags.append(b.tag)
PTags.append([b.a, b.b])
# print(time.time() -t0)
d2 = distances[Indexes][::2] / 2 + distances[Indexes][1::2] / 2
else:
n_diffu = len(tag_diffu)
Indexes = list(range(n_diffu))
Btags = [None] * n_diffu
PTags = [[t] for t in tag_diffu]
d2 = distances[Indexes]
activated = []
for iD, (btag, ptags) in enumerate(zip(Btags, PTags)):
# print(d2.shape)
# print(d2[iD])
for iorigin, di in enumerate(d2[iD]):
if iorigin in activated:
# Needed because we don't want an origin to be activated
# twice
continue
if di > cut_off_inte:
continue
if np.random.rand() > p_inte:
continue
for P in lPolymers:
if not P.has_origin(tag_origin[iorigin]):
continue
if diff_bind_when_free and \
not diff_bind_when_on_DNA:
Release([btag], snp) # Break the dimer
btag = None # We need btag only in the case where they stays attached
if not diff_alone:
# Or attached separatly or already bound:
if diff_bind_when_free:
# We are sure they are two and we can
# start
Change_type('F_Diff', ptags,
snp) # Diffusive element attached
particular_origin = tag_origin[iorigin]
new_btags = Bind(
"Mono_Diff",
[[particular_origin, ptags[0]],
[particular_origin, ptags[1]]], snp)
Change_type('A_Ori', [particular_origin], snp)
activated.append(iorigin)
P.add_fork(ptags, particular_origin, new_btags,
btag)
else:
Change_type('F_Diff', ptags,
snp) # Diffusive element attached
particular_origin = tag_origin[iorigin]
new_btags = Bind(
"Mono_Diff",
[[particular_origin, ptags[0]]], snp)
start = P.attach_one_diff(
ptags[0], particular_origin, new_btags[0])
if start:
# get particles involves
p1, p2 = P.get_diff_at_origin(
particular_origin)
if diff_bind_when_on_DNA:
btag = Bind("Diff_Diff",
[[p1[0], p2[0]]], snp)[0]
Change_type('A_Ori', [particular_origin],
snp)
P.add_fork([p1[0], p2[0]],
particular_origin,
[p1[1], p2[1]], btag)
else:
# start when touched and release
particular_origin = tag_origin[iorigin]
activated.append(iorigin)
Change_type('A_Ori', [particular_origin], snp)
P.add_fork([None, None], particular_origin,
[None, None], None)
break
# If we arrive there it means that one interaction has beeen
# found
break
# t0 = time.time()
with open(data_folder + "polymer_timing.dat", "wb") as f:
cPickle.dump(lPolymers, f)
# print(time.time() -t0)
# Then if it is the case attach them according to p law to the origin
print(gauss.get_energy(all_beads), wall_force_slj.get_energy(all_beads))
print(time.time() - t0)
def create_initial_configuration(traj):
len_chrom = traj["len_chrom"]
Cent = traj["Cent"]
p_ribo = traj["p_ribo"]
R = traj["R"]
micron = traj["micron"]
# Diffusing elements
N_diffu = traj["N_diffu"]
r_diffu = traj.get("diameter_diffu", 1) / 2
# exit()
p_origins = traj["p_origins"]
if type(len_chrom) != list:
len_chrom, _ = load_lengths_and_centro(len_chrom, traj["coarse"])
if type(Cent) != list:
_, Cent = load_lengths_and_centro(Cent, traj["coarse"])
if type(p_origins) != list:
p_origins = load_ori_position(traj["p_origins"], traj["ori_type"],
len_chrom, traj["coarse"])
p_ribo = [[int(position) // int(traj["coarse"] // 1000), length]
for position, length in p_ribo]
two_types = traj.get("two_types", False)
p_second = traj.get("p_second", [])
dstrength = traj.get("dstrength", 0)
strengths = None
if p_second != []:
# Assign delta_strength
if dstrength != 0:
strengths = []
for bands, pos in zip(p_second, p_origins):
strengths.append([])
for p in pos:
found = False
for Intervals in bands:
if Intervals[0] < p < Intervals[1]:
strengths[-1].append(dstrength)
found = True
break
if not found:
strengths[-1].append(1)
ps = []
for ch in p_second:
ps.append([])
for p1, p2 in ch:
ps[-1] += range(p1, p2)
p_second = ps
boundaries = traj.get("boundaries", False)
if boundaries:
extra_boundaries = load_boundaries(coarse=traj["coarse"])
print("strengths", strengths)
# Yeast case
spb = traj["spb"]
nucleole = traj["nucleole"]
telomere = traj["telomere"]
microtubule_length = traj["microtubule_length"] * micron
special_start = traj["special_start"]
visu = traj["visu"]
dump_hic = traj["dump_hic"]
# Scenari
diff_bind_when_free = traj["diff_bind_when_free"]
# Simulation parameters
Np = len(len_chrom)
assert (len(len_chrom) == len(Cent) == len(p_ribo))
if special_start:
Sim = create_init_conf_yeast(len_chrom=len_chrom,
dist_centro=Cent,
p_ribo=p_ribo,
Radius=R - 1,
Mt=microtubule_length)
else:
Sim = []
spbp = 0 if not spb else 1
Total_particle = sum(len_chrom) + N_diffu * 2 + spbp
list_nuc = [
list(range(start, start + size)) if size != 0 else []
for start, size in p_ribo
]
# print(list_nuc)
# exit()
snapshot = data.make_snapshot(N=Total_particle,
box=data.boxdim(L=2 * R),
bond_types=['polymer'])
spbb = Np if spb else 0
if visu:
spbb = 0
bond_diffu = 0
if diff_bind_when_free:
bond_diffu = N_diffu
snapshot.bonds.resize(sum(len_chrom) - len(len_chrom) + bond_diffu + spbb)
bond_list = ['Mono_Mono', 'Diff_Diff', 'Mono_Diff']
if spb:
bond_list += ["Spb_Cen"]
if nucleole:
bond_list += ["Mono_Nuc", "Nuc_Nuc"]
snapshot.bonds.types = bond_list
plist = ['Mono', 'Ori', 'Diff', 'S_Diff', 'F_Diff', "I_Diff"]
if two_types:
plist.append("Mono1")
if spb:
plist.append("Spb")
if visu:
plist.append("Cen")
if nucleole:
plist += ['Nuc', 'A_Nuc', 'P_Nuc']
if telomere:
plist += ["Telo"]
snapshot.particles.types = plist
offset_bond = 0
offset_particle = 0
lPolymers = []
################################################
# Polymer chains
Cen_pos = []
list_ori = []
for i in range(Np):
found_cen = False
npp = len_chrom[i] # Number of particles
# Position of origin of replication
pos_origins = p_origins[i]
istrength = None
if strengths is not None:
istrength = strengths[i]
if Sim == []:
initp = 2 * np.random.rand(3) - 1
else:
# print(i)
initp = Sim.molecules[i].coords[0]
for p in range(npp - 1):
inuc = 0
if nucleole:
if p in list_nuc[i]:
inuc += 1
if p + 1 in list_nuc[i]:
inuc += 1
snapshot.bonds.group[offset_bond + p] = [
offset_particle + p, offset_particle + p + 1
]
if inuc == 0:
snapshot.bonds.typeid[offset_bond + p] = bond_list.index(
'Mono_Mono') # polymer_A
if inuc == 1:
snapshot.bonds.typeid[offset_bond + p] = bond_list.index(
'Mono_Nuc') # polymer_A
if inuc == 2:
snapshot.bonds.typeid[offset_bond + p] = bond_list.index(
'Nuc_Nuc') # polymer_A
offset_bond += npp - 1
for p in range(npp):
# print(offset_bond, offset_bond + p)
if Sim == []:
new = 2 * (2 * np.random.rand(3) - 1)
while linalg.norm(initp + new) > R - 1:
new = 2 * (2 * np.random.rand(3) - 1)
initp += new
else:
initp = Sim.molecules[i].coords[p]
snapshot.particles.position[offset_particle + p] = initp
# snapshot.particles.diameter[offset_particle + p] = 1
if p in pos_origins:
list_ori.append(offset_particle + p)
if visu and (p in pos_origins):
snapshot.particles.typeid[offset_particle + p] = plist.index(
'Ori') # Ori
else:
snapshot.particles.typeid[offset_particle + p] = plist.index(
'Mono') # A
if two_types and p in p_second[i]:
snapshot.particles.typeid[offset_particle +
p] = plist.index('Mono1') # A
if spb and p == Cent[i]:
Cen_pos.append(offset_particle + p)
if visu:
snapshot.particles.typeid[offset_particle +
p] = plist.index('Cen') # A
found_cen = True
if nucleole and p in list_nuc[i]:
snapshot.particles.typeid[offset_particle +
p] = plist.index('Nuc')
if telomere and (p == 0 or p == npp - 1):
snapshot.particles.typeid[offset_particle +
p] = plist.index('Telo')
if boundaries and p in extra_boundaries[i]:
snapshot.particles.typeid[offset_particle +
p] = plist.index('Telo')
lPolymers.append(
Polymer(i,
offset_particle,
offset_particle + npp - 1,
[po + offset_particle for po in pos_origins],
strengths=istrength))
offset_particle += npp
assert (found_cen == spb)
phic = 0
if dump_hic:
phic = 0 + offset_particle - 1
###################################################
# SPD
tag_spb = None
if spb:
tag_spb = 0 + offset_particle
# print(tag_spb)
# print(snapshot.particles[offset_particle])
snapshot.particles.position[offset_particle] = [-R + 0.1, 0, 0]
snapshot.particles.typeid[offset_particle] = plist.index('Spb')
offset_particle += 1
if not visu:
for i in range(Np):
# print(offset_particle - 1, Cen_pos[i])
snapshot.bonds.group[offset_bond] = [
offset_particle - 1, Cen_pos[i]
]
snapshot.bonds.typeid[offset_bond] = bond_list.index(
'Spb_Cen') # polymer_A
offset_bond += 1
############################################################
# Diffusing elements
# Defining useful classes
# Defining particles and bonds for the simulation
p_tag_list = []
for i in range(N_diffu):
npp = 2 # Number of particles
initp = (R - 2) * (2 * np.random.rand(3) - 1)
while linalg.norm(initp) > R - 1:
initp = (R - 2) * (2 * np.random.rand(3) - 1)
if diff_bind_when_free:
for p in range(npp - 1):
snapshot.bonds.group[offset_bond + p] = [
offset_particle + p, offset_particle + p + 1
]
snapshot.bonds.typeid[offset_bond + p] = bond_list.index(
'Diff_Diff') # Diff_Diff
offset_bond += npp - 1
p_tag_list.append([])
for p in range(npp):
# print(offset_bond, offset_bond + p)
if diff_bind_when_free:
new = 2 * (2 * np.random.rand(3) - 1)
while linalg.norm(initp + new) > R - 1:
new = 2 * (2 * np.random.rand(3) - 1)
# print(initp,new,R,linalg.norm(initp + new))
# exit()
initp += new
else:
initp = (R - 2) * (2 * np.random.rand(3) - 1)
while linalg.norm(initp) > R - 1:
initp = (R - 2) * (2 * np.random.rand(3) - 1)
snapshot.particles.position[offset_particle + p] = initp
# snapshot.particles.mass[offset_particle + p] = r_diffu**3 * 2**3
snapshot.particles.typeid[offset_particle + p] = plist.index(
"Diff") # Diffu
p_tag_list[-1].append(offset_particle + p)
offset_particle += npp
# Load the configuration
for i, p in enumerate(snapshot.bonds.group):
if p[0] == p[1]:
print(i, p)
return snapshot, phic, tag_spb, bond_list, plist, Cen_pos, lPolymers, list_ori, p_tag_list
def test_lattice(self):
N=128;
latticeq = [[1,0,0,0] for i in range(N)];
k = 10.0;
kalt = np.exp(15);
dx2d = np.array([0.1, 0.1, 0.0]);
theta = np.pi/6;
eng_check2d = round(N*k*dx2d.dot(dx2d), 3);
dx3d = np.array([0.1, 0.1, 0.1]);
eng_check3d = round(N*k*dx3d.dot(dx3d), 3);
dq = np.array([np.cos(theta/2.0),0.,0.,np.sin(theta/2)])
ddq = np.array([1.,0.,0.,0.]) - dq;
eng_checkq = round(10.0*k*N*ddq.dot(ddq), 3);
hexuc = hoomd.lattice.hex(a=2.0);
self.system = init.read_snapshot(hexuc.get_snapshot());
self.system.replicate(nx=8, ny=8, nz=1);
self.snapshot2d = self.system.take_snapshot(particles=True); #data.make_snapshot(N=N, box=data.boxdim(L=L, dimensions=3), particle_types=['A'])
lattice2d = [];
if hoomd.comm.get_rank() == 0:
lattice2d = self.snapshot2d.particles.position[:];
self.snapshot2d_s = data.make_snapshot(N=N, box=self.system.box, particle_types=['A']);
if hoomd.comm.get_rank() == 0:
self.snapshot2d_s.particles.position[:] = self.snapshot2d.particles.position[:]+dx2d;
self.snapshot2d_s.particles.orientation[:] = np.array([dq for _ in range(N)]);
del self.system
context.initialize();
bccuc = hoomd.lattice.bcc(a=2.0);
self.system = init.read_snapshot(bccuc.get_snapshot());
self.system.replicate(nx=4, ny=4, nz=4);
self.snapshot3d = self.system.take_snapshot(particles=True); #data.make_snapshot(N=N, box=data.boxdim(L=L, dimensions=3), particle_types=['A'])
lattice3d = [];
if hoomd.comm.get_rank() == 0:
lattice3d = self.snapshot3d.particles.position[:];
self.snapshot3d_s = data.make_snapshot(N=N, box=self.system.box, particle_types=['A']);
if hoomd.comm.get_rank() == 0:
self.snapshot3d_s.particles.position[:] = self.snapshot3d.particles.position[:]+dx3d;
self.snapshot3d_s.particles.orientation[:] = np.array([dq for _ in range(N)]);
del self.system
context.initialize();
# sphere
print("****************************************")
print("* sphere *")
print("****************************************")
# d = 0.0014284726343172743, p = 0.20123046875
uein = 1.5 # kT
diam = 1.0;
self.system = init.read_snapshot(self.snapshot3d)
self.mc = hpmc.integrate.sphere(seed=2398, d=0.0)
self.mc.shape_param.set('A', diameter=diam)
self.run_test(latticep=lattice3d, latticeq=[], k=k, kalt=kalt, q=0, qalt=0, uein=1.5, snapshot_s=self.snapshot3d_s, eng_check=eng_check3d, d=0.001428 );
self.tear_down()
# ellipsoid
print("****************************************")
print("* ellipsoid *")
print("****************************************")
# a = 0.00038920117896296716, p = 0.2035860456051452
# d = 0.0014225507698958867, p = 0.19295361127422195
a = 0.5;
b = 0.54;
c = 0.35;
uein = 3.0 # kT
self.system = init.read_snapshot(self.snapshot3d)
self.mc = hpmc.integrate.ellipsoid(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', a=a, b=b, c=c)
self.run_test(latticep=lattice3d, latticeq=latticeq, k=k, kalt=kalt, q=k*10.0, qalt=kalt*10.0, uein=3.0, snapshot_s=self.snapshot3d_s, eng_check=(eng_check3d+eng_checkq), a = 0.000389, d = 0.001423);
self.tear_down()
# convex_polygon
print("****************************************")
print("* convex_polygon *")
print("****************************************")
# a = 0.001957745443687172, p = 0.19863574351978172
# d = 0.0017185407622231329, p = 0.2004306126443531
self.system = init.read_snapshot(self.snapshot2d)
v = 0.33*np.array([(-1,-1), (1,-1), (1,1), (-1,1)]);
self.mc = hpmc.integrate.convex_polygon(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', vertices=v)
self.run_test(latticep=lattice2d, latticeq=latticeq, k=k, kalt=kalt, q=k*10.0, qalt=kalt*10.0, uein=1.5, snapshot_s=self.snapshot2d_s, eng_check=(eng_check2d+eng_checkq), a = 0.001958, d = 0.001719);
self.tear_down()
# convex_spheropolygon
print("****************************************")
print("* convex_spheropolygon *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot2d)
v = 0.33*np.array([(-1,-1), (1,-1), (1,1), (-1,1)]);
r = 0.1234;
self.mc = hpmc.integrate.convex_spheropolygon(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', vertices=v, sweep_radius=r)
diff = (np.array(v) - np.array(self.mc.shape_param['A'].vertices)).flatten();
self.run_test(latticep=lattice2d, latticeq=latticeq, k=k, kalt=kalt, q=k*10.0, qalt=kalt*10.0, uein=None, snapshot_s=self.snapshot2d_s, eng_check=(eng_check2d+eng_checkq));
self.tear_down()
#simple_polygon
print("****************************************")
print("* simple_polygon *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot2d)
v = 0.33*np.array([(-1,-1), (1,-1), (1,1), (-1,1)]);
self.mc = hpmc.integrate.simple_polygon(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', vertices=v)
self.run_test(latticep=lattice2d, latticeq=latticeq, k=k, kalt=kalt, q=k*10.0, qalt=kalt*10.0, uein=None, snapshot_s=self.snapshot2d_s, eng_check=(eng_check2d+eng_checkq));
self.tear_down()
# polyhedron
print("****************************************")
print("* polyhedron *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
v = 0.33*np.array([(-0.5, -0.5, -0.5), (-0.5, -0.5, 0.5), (-0.5, 0.5, -0.5), (-0.5, 0.5, 0.5), (0.5, -0.5, -0.5), (0.5, -0.5, 0.5), (0.5, 0.5, -0.5), (0.5, 0.5, 0.5)]);
f = [(7, 3, 1, 5), (7, 5, 4, 6), (7, 6, 2, 3), (3, 2, 0, 1), (0, 2, 6, 4), (1, 0, 4, 5)];
r = 0.0;
self.mc = hpmc.integrate.polyhedron(seed=10);
self.mc.shape_param.set('A', vertices=v, faces =f, sweep_radius=r);
diff = (np.array(v) - np.array(self.mc.shape_param['A'].vertices)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
diff = (np.array(f) - np.array(self.mc.shape_param['A'].faces)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
self.assertAlmostEqual(self.mc.shape_param['A'].sweep_radius, r);
del self.mc
del self.system
context.initialize()
# convex_polyhedron
print("****************************************")
print("* convex_polyhedron *")
print("****************************************")
#a = 0.00038920117896296716, p = 0.2035860456051452
#d = 0.0014225507698958867, p = 0.19295361127422195
self.system = init.read_snapshot(self.snapshot3d)
v = 0.33*np.array([(1,1,1), (1,-1,1), (-1,-1,1), (-1,1,1),(1,1,-1), (1,-1,-1), (-1,-1,-1), (-1,1,-1)]);
self.mc = hpmc.integrate.convex_polyhedron(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', vertices=v)
self.run_test(latticep=lattice3d, latticeq=latticeq, k=k, kalt=kalt, q=k*10.0, qalt=kalt*10.0, uein=3.0, snapshot_s=self.snapshot3d_s, eng_check=(eng_check3d+eng_checkq), a = 0.0003892, d = 0.00142255);
self.tear_down()
# convex_spheropolyhedron
print("****************************************")
print("* convex_spheropolyhedron *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
v = 0.33*np.array([(1,1,1), (1,-1,1), (-1,-1,1), (-1,1,1),(1,1,-1), (1,-1,-1), (-1,-1,-1), (-1,1,-1)]);
r = 0.1234;
self.mc = hpmc.integrate.convex_spheropolyhedron(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', vertices=v, sweep_radius=r)
self.run_test(latticep=lattice3d, latticeq=latticeq, k=k, kalt=kalt, q=k*10.0, qalt=kalt*10.0, uein=None, snapshot_s=self.snapshot3d_s, eng_check=(eng_check3d+eng_checkq));
self.tear_down()
# faceted_sphere
print("****************************************")
print("* faceted_sphere *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
v = 0.33*np.array([(-1,-1,-1),(-1,-1,1),(-1,1,-1),(-1,1,1),(1,-1,-1),(1,-1,1),(1,1,-1),(1,1,1)]);
offs = [-1]*6;
norms =[(-1,0,0), (1,0,0), (0,1,0,), (0,-1,0), (0,0,1), (0,0,-1)];
diam = 1.0;
orig = (0,0,0);
self.mc = hpmc.integrate.faceted_sphere(seed=10, d=0.0, a=0.0);
self.mc.shape_param.set('A', normals=norms,
offsets=offs,
vertices=v,
diameter=diam,
origin=orig);
self.run_test(latticep=lattice3d, latticeq=latticeq, k=k, kalt=kalt, q=k*10.0, qalt=kalt*10.0, uein=None, snapshot_s=self.snapshot3d_s, eng_check=(eng_check3d+eng_checkq));
self.tear_down()
# sphinx
print("****************************************")
print("* sphinx *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
cent = [(0,0,0), (0,0,1.15), (0,0,-1.15)]
diams = [1,-1.2,-1.2];
self.mc = hpmc.integrate.sphinx(seed=10, d=0.0, a=0.0);
self.mc.shape_param.set('A', diameters=diams, centers=cent);
self.run_test(latticep=lattice3d, latticeq=latticeq, k=k, kalt=kalt, q=k*10.0, qalt=kalt*10.0, uein=None, snapshot_s=self.snapshot3d_s, eng_check=(eng_check3d+eng_checkq));
self.tear_down()
# sphere_union
print("****************************************")
print("* sphere_union *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
cent = [(0,0,0), (0,0,0.15), (0,0,-0.15)]
diams = [1,1,1];
self.mc = hpmc.integrate.sphere_union(seed=10, d=0.0, a=0.0);
self.mc.shape_param.set('A', diameters=diams, centers=cent);
self.run_test(latticep=lattice3d, latticeq=latticeq, k=k, kalt=kalt, q=k*10.0, qalt=kalt*10.0, uein=None, snapshot_s=self.snapshot3d_s, eng_check=(eng_check3d+eng_checkq));
self.tear_down()
def test_access(self):
N=2
L=10
context.initialize()
self.snapshot = data.make_snapshot(N=N, box=data.boxdim(L=L, dimensions=2), particle_types=['A'])
# sphere
diam = 1.125;
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.sphere(seed=2398, d=0.0)
self.mc.shape_param.set('A', diameter=diam)
self.assertAlmostEqual(self.mc.shape_param['A'].diameter, diam);
del self.mc
del self.system
context.initialize()
# ellipsoid
a = 1.125;
b = 0.238;
c = 2.25;
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.ellipsoid(seed=2398, d=0.0)
self.mc.shape_param.set('A', a=a, b=b, c=c)
self.assertAlmostEqual(self.mc.shape_param['A'].a, a);
self.assertAlmostEqual(self.mc.shape_param['A'].b, b);
self.assertAlmostEqual(self.mc.shape_param['A'].c, c);
del self.mc
del self.system
context.initialize()
# convex_polygon
v = [(-1,-1), (1,-1), (1,1), (-1,1)];
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.convex_polygon(seed=2398, d=0.1, a=0.1)
self.mc.shape_param.set('A', vertices=v)
diff = (np.array(v) - np.array(self.mc.shape_param['A'].vertices)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
del self.mc
del self.system
context.initialize()
# convex_spheropolygon
v = [(-1,-1), (1,-1), (1,1), (-1,1)];
r = 0.1234;
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.convex_spheropolygon(seed=2398, d=0.1, a=0.1)
self.mc.shape_param.set('A', vertices=v, sweep_radius=r)
diff = (np.array(v) - np.array(self.mc.shape_param['A'].vertices)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
self.assertAlmostEqual(self.mc.shape_param['A'].sweep_radius, r);
del self.mc
del self.system
context.initialize()
#simple_polygon
v = [(-1,-1), (1,-1), (1,1), (-1,1)];
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.simple_polygon(seed=2398, d=0.1, a=0.1)
self.mc.shape_param.set('A', vertices=v)
diff = (np.array(v) - np.array(self.mc.shape_param['A'].vertices)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
del self.mc
del self.system
context.initialize()
# polyhedron
import math
v = [(-0.5, -0.5, 0), (-0.5, 0.5, 0), (0.5, -0.5, 0), (0.5, 0.5, 0), (0,0, 1.0/math.sqrt(2)),(0,0,-1.0/math.sqrt(2))];
f = [(0,4,1),(1,4,2),(2,4,3),(3,4,0),(0,5,1),(1,5,2),(2,5,3),(3,5,0)]
r = 0.0;
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.polyhedron(seed=10);
self.mc.shape_param.set('A', vertices=v, faces =f, sweep_radius=r);
diff = (np.array(v) - np.array(self.mc.shape_param['A'].vertices)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
diff = (np.array(f) - np.array(self.mc.shape_param['A'].faces)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
self.assertAlmostEqual(self.mc.shape_param['A'].sweep_radius, r);
del self.mc
del self.system
context.initialize()
# convex_polyhedron
v = [(1,1,1), (1,-1,1), (-1,-1,1), (-1,1,1),(1,1,-1), (1,-1,-1), (-1,-1,-1), (-1,1,-1)];
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.convex_polyhedron(seed=2398, d=0.1, a=0.1)
self.mc.shape_param.set('A', vertices=v)
diff = (np.array(v) - np.array(self.mc.shape_param['A'].vertices)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
del self.mc
del self.system
context.initialize()
# convex_spheropolyhedron
v = [(1,1,1), (1,-1,1), (-1,-1,1), (-1,1,1),(1,1,-1), (1,-1,-1), (-1,-1,-1), (-1,1,-1)];
r = 0.1234;
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.convex_spheropolyhedron(seed=2398, d=0.1, a=0.1)
self.mc.shape_param.set('A', vertices=v, sweep_radius=r)
diff = (np.array(v) - np.array(self.mc.shape_param['A'].vertices)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
self.assertAlmostEqual(self.mc.shape_param['A'].sweep_radius, r);
del self.mc
del self.system
context.initialize()
# faceted_sphere
v = [(-1,-1,-1),(-1,-1,1),(-1,1,-1),(-1,1,1),(1,-1,-1),(1,-1,1),(1,1,-1),(1,1,1)];
offs = [-1]*6;
norms =[(-1,0,0), (1,0,0), (0,1,0,), (0,-1,0), (0,0,1), (0,0,-1)];
diam = 2;
orig = (0,0,0);
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.faceted_sphere(seed=10);
self.mc.shape_param.set('A', normals=norms,
offsets=offs,
vertices=v,
diameter=diam,
origin=orig);
diff = (np.array(v) - np.array(self.mc.shape_param['A'].vertices)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
diff = (np.array(offs) - np.array(self.mc.shape_param['A'].offsets)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
diff = (np.array(norms) - np.array(self.mc.shape_param['A'].normals)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
diff = (np.array(orig) - np.array(self.mc.shape_param['A'].origin)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
self.assertAlmostEqual(self.mc.shape_param['A'].diameter, diam);
del self.mc
del self.system
context.initialize()
# sphinx
# GPU Sphinx is not built on most the time
if not hoomd.context.exec_conf.isCUDAEnabled():
cent = [(0,0,0), (0,0,1.15), (0,0,-1.15)]
diams = [2,-2.2,-2.2];
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.sphinx(seed=10);
self.mc.shape_param.set('A', diameters=diams, centers=cent);
diff = (np.array(cent) - np.array(self.mc.shape_param['A'].centers)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
diff = (np.array(diams) - np.array(self.mc.shape_param['A'].diameters)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
del self.mc
del self.system
context.initialize()
# sphere_union
cent = [(0,0,0), (0,0,1.15), (0,0,-1.15)]
diams = [2,2.2,1.75];
self.system = init.read_snapshot(self.snapshot)
self.mc = hpmc.integrate.sphere_union(seed=10);
self.mc.shape_param.set('A', diameters=diams, centers=cent);
diff = (np.array(cent) - np.array(self.mc.shape_param['A'].centers)).flatten();
self.assertAlmostEqual(diff.dot(diff), 0);
for i,m in enumerate(self.mc.shape_param['A'].members):
self.assertAlmostEqual(m.diameter, diams[i]);
del self.mc
del self.system
del self.snapshot
context.initialize()
def test_lattice(self):
N = 128
latticeq = [[1, 0, 0, 0] for i in range(N)]
k = 10.0
kalt = np.exp(15)
dx2d = np.array([0.1, 0.1, 0.0])
theta = np.pi / 6
eng_check2d = round(N * k * dx2d.dot(dx2d), 3)
dx3d = np.array([0.1, 0.1, 0.1])
eng_check3d = round(N * k * dx3d.dot(dx3d), 3)
dq = np.array([np.cos(theta / 2.0), 0., 0., np.sin(theta / 2)])
ddq = np.array([1., 0., 0., 0.]) - dq
eng_checkq = round(10.0 * k * N * ddq.dot(ddq), 3)
hexuc = hoomd.lattice.hex(a=2.0)
self.system = init.read_snapshot(hexuc.get_snapshot())
self.system.replicate(nx=8, ny=8, nz=1)
self.snapshot2d = self.system.take_snapshot(particles=True)
#data.make_snapshot(N=N, box=data.boxdim(L=L, dimensions=3), particle_types=['A'])
lattice2d = []
if hoomd.comm.get_rank() == 0:
lattice2d = self.snapshot2d.particles.position[:]
self.snapshot2d_s = data.make_snapshot(N=N,
box=self.system.box,
particle_types=['A'])
if hoomd.comm.get_rank() == 0:
self.snapshot2d_s.particles.position[:] = self.snapshot2d.particles.position[:] + dx2d
self.snapshot2d_s.particles.orientation[:] = np.array(
[dq for _ in range(N)])
del self.system
context.initialize()
bccuc = hoomd.lattice.bcc(a=2.0)
self.system = init.read_snapshot(bccuc.get_snapshot())
self.system.replicate(nx=4, ny=4, nz=4)
self.snapshot3d = self.system.take_snapshot(particles=True)
#data.make_snapshot(N=N, box=data.boxdim(L=L, dimensions=3), particle_types=['A'])
lattice3d = []
if hoomd.comm.get_rank() == 0:
lattice3d = self.snapshot3d.particles.position[:]
self.snapshot3d_s = data.make_snapshot(N=N,
box=self.system.box,
particle_types=['A'])
if hoomd.comm.get_rank() == 0:
self.snapshot3d_s.particles.position[:] = self.snapshot3d.particles.position[:] + dx3d
self.snapshot3d_s.particles.orientation[:] = np.array(
[dq for _ in range(N)])
del self.system
context.initialize()
# sphere
print("****************************************")
print("* sphere *")
print("****************************************")
# d = 0.0014284726343172743, p = 0.20123046875
uein = 1.5 # kT
diam = 1.0
self.system = init.read_snapshot(self.snapshot3d)
self.mc = hpmc.integrate.sphere(seed=2398, d=0.0)
self.mc.shape_param.set('A', diameter=diam)
self.run_test(latticep=lattice3d,
latticeq=[],
k=k,
kalt=kalt,
q=0,
qalt=0,
uein=1.5,
snapshot_s=self.snapshot3d_s,
eng_check=eng_check3d,
d=0.001428)
self.tear_down()
# ellipsoid
print("****************************************")
print("* ellipsoid *")
print("****************************************")
# a = 0.00038920117896296716, p = 0.2035860456051452
# d = 0.0014225507698958867, p = 0.19295361127422195
a = 0.5
b = 0.54
c = 0.35
uein = 3.0 # kT
self.system = init.read_snapshot(self.snapshot3d)
self.mc = hpmc.integrate.ellipsoid(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', a=a, b=b, c=c)
self.run_test(latticep=lattice3d,
latticeq=latticeq,
k=k,
kalt=kalt,
q=k * 10.0,
qalt=kalt * 10.0,
uein=3.0,
snapshot_s=self.snapshot3d_s,
eng_check=(eng_check3d + eng_checkq),
a=0.000389,
d=0.001423)
self.tear_down()
# convex_polygon
print("****************************************")
print("* convex_polygon *")
print("****************************************")
# a = 0.001957745443687172, p = 0.19863574351978172
# d = 0.0017185407622231329, p = 0.2004306126443531
self.system = init.read_snapshot(self.snapshot2d)
v = 0.33 * np.array([(-1, -1), (1, -1), (1, 1), (-1, 1)])
self.mc = hpmc.integrate.convex_polygon(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', vertices=v)
self.run_test(latticep=lattice2d,
latticeq=latticeq,
k=k,
kalt=kalt,
q=k * 10.0,
qalt=kalt * 10.0,
uein=1.5,
snapshot_s=self.snapshot2d_s,
eng_check=(eng_check2d + eng_checkq),
a=0.001958,
d=0.001719)
self.tear_down()
# convex_spheropolygon
print("****************************************")
print("* convex_spheropolygon *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot2d)
v = 0.33 * np.array([(-1, -1), (1, -1), (1, 1), (-1, 1)])
r = 0.1234
self.mc = hpmc.integrate.convex_spheropolygon(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', vertices=v, sweep_radius=r)
diff = (np.array(v) -
np.array(self.mc.shape_param['A'].vertices)).flatten()
self.run_test(latticep=lattice2d,
latticeq=latticeq,
k=k,
kalt=kalt,
q=k * 10.0,
qalt=kalt * 10.0,
uein=None,
snapshot_s=self.snapshot2d_s,
eng_check=(eng_check2d + eng_checkq))
self.tear_down()
#simple_polygon
print("****************************************")
print("* simple_polygon *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot2d)
v = 0.33 * np.array([(-1, -1), (1, -1), (1, 1), (-1, 1)])
self.mc = hpmc.integrate.simple_polygon(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', vertices=v)
self.run_test(latticep=lattice2d,
latticeq=latticeq,
k=k,
kalt=kalt,
q=k * 10.0,
qalt=kalt * 10.0,
uein=None,
snapshot_s=self.snapshot2d_s,
eng_check=(eng_check2d + eng_checkq))
self.tear_down()
# polyhedron
print("****************************************")
print("* polyhedron *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
v = 0.33 * np.array([(-0.5, -0.5, -0.5), (-0.5, -0.5, 0.5),
(-0.5, 0.5, -0.5), (-0.5, 0.5, 0.5),
(0.5, -0.5, -0.5), (0.5, -0.5, 0.5),
(0.5, 0.5, -0.5), (0.5, 0.5, 0.5)])
f = [(7, 3, 1, 5), (7, 5, 4, 6), (7, 6, 2, 3), (3, 2, 0, 1),
(0, 2, 6, 4), (1, 0, 4, 5)]
r = 0.0
self.mc = hpmc.integrate.polyhedron(seed=10)
self.mc.shape_param.set('A', vertices=v, faces=f, sweep_radius=r)
diff = (np.array(v) -
np.array(self.mc.shape_param['A'].vertices)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
diff = (np.array(f) -
np.array(self.mc.shape_param['A'].faces)).flatten()
self.assertAlmostEqual(diff.dot(diff), 0)
self.assertAlmostEqual(self.mc.shape_param['A'].sweep_radius, r)
del self.mc
del self.system
context.initialize()
# convex_polyhedron
print("****************************************")
print("* convex_polyhedron *")
print("****************************************")
#a = 0.00038920117896296716, p = 0.2035860456051452
#d = 0.0014225507698958867, p = 0.19295361127422195
self.system = init.read_snapshot(self.snapshot3d)
v = 0.33 * np.array([(1, 1, 1), (1, -1, 1), (-1, -1, 1), (-1, 1, 1),
(1, 1, -1), (1, -1, -1), (-1, -1, -1),
(-1, 1, -1)])
self.mc = hpmc.integrate.convex_polyhedron(seed=2398, d=0.0, a=0.0)
self.mc.shape_param.set('A', vertices=v)
self.run_test(latticep=lattice3d,
latticeq=latticeq,
k=k,
kalt=kalt,
q=k * 10.0,
qalt=kalt * 10.0,
uein=3.0,
snapshot_s=self.snapshot3d_s,
eng_check=(eng_check3d + eng_checkq),
a=0.0003892,
d=0.00142255)
self.tear_down()
# convex_spheropolyhedron
print("****************************************")
print("* convex_spheropolyhedron *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
v = 0.33 * np.array([(1, 1, 1), (1, -1, 1), (-1, -1, 1), (-1, 1, 1),
(1, 1, -1), (1, -1, -1), (-1, -1, -1),
(-1, 1, -1)])
r = 0.1234
self.mc = hpmc.integrate.convex_spheropolyhedron(seed=2398,
d=0.0,
a=0.0)
self.mc.shape_param.set('A', vertices=v, sweep_radius=r)
self.run_test(latticep=lattice3d,
latticeq=latticeq,
k=k,
kalt=kalt,
q=k * 10.0,
qalt=kalt * 10.0,
uein=None,
snapshot_s=self.snapshot3d_s,
eng_check=(eng_check3d + eng_checkq))
self.tear_down()
# faceted_sphere
print("****************************************")
print("* faceted_sphere *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
v = 0.33 * np.array([(-1, -1, -1), (-1, -1, 1), (-1, 1, -1),
(-1, 1, 1), (1, -1, -1), (1, -1, 1), (1, 1, -1),
(1, 1, 1)])
offs = [-1] * 6
norms = [(-1, 0, 0), (1, 0, 0), (
0,
1,
0,
), (0, -1, 0), (0, 0, 1), (0, 0, -1)]
diam = 1.0
orig = (0, 0, 0)
self.mc = hpmc.integrate.faceted_sphere(seed=10, d=0.0, a=0.0)
self.mc.shape_param.set('A',
normals=norms,
offsets=offs,
vertices=v,
diameter=diam,
origin=orig)
self.run_test(latticep=lattice3d,
latticeq=latticeq,
k=k,
kalt=kalt,
q=k * 10.0,
qalt=kalt * 10.0,
uein=None,
snapshot_s=self.snapshot3d_s,
eng_check=(eng_check3d + eng_checkq))
self.tear_down()
# sphinx
print("****************************************")
print("* sphinx *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
cent = [(0, 0, 0), (0, 0, 1.15), (0, 0, -1.15)]
diams = [1, -1.2, -1.2]
self.mc = hpmc.integrate.sphinx(seed=10, d=0.0, a=0.0)
self.mc.shape_param.set('A', diameters=diams, centers=cent)
self.run_test(latticep=lattice3d,
latticeq=latticeq,
k=k,
kalt=kalt,
q=k * 10.0,
qalt=kalt * 10.0,
uein=None,
snapshot_s=self.snapshot3d_s,
eng_check=(eng_check3d + eng_checkq))
self.tear_down()
# sphere_union
print("****************************************")
print("* sphere_union *")
print("****************************************")
self.system = init.read_snapshot(self.snapshot3d)
cent = [(0, 0, 0), (0, 0, 0.15), (0, 0, -0.15)]
diams = [1, 1, 1]
self.mc = hpmc.integrate.sphere_union(seed=10, d=0.0, a=0.0)
self.mc.shape_param.set('A', diameters=diams, centers=cent)
self.run_test(latticep=lattice3d,
latticeq=latticeq,
k=k,
kalt=kalt,
q=k * 10.0,
qalt=kalt * 10.0,
uein=None,
snapshot_s=self.snapshot3d_s,
eng_check=(eng_check3d + eng_checkq))
self.tear_down()
def create_empty(**kwargs):
snap = data.make_snapshot(**kwargs)
return init.read_snapshot(snap)
def setUp(self):
snap = data.make_snapshot(N=0, box=data.boxdim(Lx=10, Ly=10, Lz=10))
self.system = init.read_snapshot(snap)
self.mc = hpmc.integrate.convex_polyhedron(seed=123)
