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): 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 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 psi6_order_from_gsd(fpath, frame=0): with gsd.fl.GSDFile(fpath, 'rb') as f_gsd: n_frames_total = f_gsd.nframes if frame > n_frames_total: raise ValueError('frames beyond n_frames_total') #translate negative indices into positive domain: abs_frame = frame -(frame//n_frames_total)*n_frames_total pos = f_gsd.read_chunk(frame=abs_frame, name='particles/position') box_array = f_gsd.read_chunk(frame=0, name='configuration/box') box = boxdim(*box_array[0:3]) psi = psi_order_delone(pos, box, nx=100, ny=100, rcut=1.3) return psi
def latticeToHoomd(a1, a2, a3=[0.,0.,1.], ndim=3): from hoomd.data import boxdim a1 = np.array(a1) a2 = np.array(a2) a3 = np.array(a3) a1.resize((3,)) a2.resize((3,)) a3.resize((3,)) xhat = np.array([1.,0.,0.]) yhat = np.array([0.,1.,0.]) zhat = np.array([0.,0.,1.]) # Find quaternion to rotate first lattice vector to x axis a1mag = np.sqrt(np.dot(a1,a1)) v1 = a1/a1mag + xhat v1mag = np.sqrt(np.dot(v1,v1)) if v1mag > 1e-6: u1 = v1/v1mag else: # a1 is antialigned with xhat, so rotate around any unit vector perpendicular to xhat u1 = yhat q1 = np.concatenate(([np.cos(np.pi/2)], np.sin(np.pi/2)*u1)) # Find quaternion to rotate second lattice vector to xy plane after applying above rotation a2prime = quatRot(q1, a2) angle = -1*np.arctan2(a2prime[2], a2prime[1]) q2 = np.concatenate(([np.cos(angle/2)], np.sin(angle/2)*xhat)) q = quatMult(q2,q1) Lx = np.sqrt(np.dot(a1, a1)) a2x = np.dot(a1, a2) / Lx Ly = np.sqrt(np.dot(a2,a2) - a2x*a2x) xy = a2x / Ly v0xv1 = np.cross(a1, a2) v0xv1mag = np.sqrt(np.dot(v0xv1, v0xv1)) Lz = np.dot(a3, v0xv1) / v0xv1mag a3x = np.dot(a1, a3) / Lx xz = a3x / Lz yz = (np.dot(a2, a3) - a2x*a3x) / (Ly*Lz) box = boxdim(Lx=Lx, Ly=Ly, Lz=Lz, xy=xy, xz=xz, yz=yz, dimensions=ndim) return box, q
def latticeToHoomd(a1, a2, a3=[0., 0., 1.], ndim=3): from hoomd.data import boxdim a1 = np.array(a1) a2 = np.array(a2) a3 = np.array(a3) a1.resize((3, )) a2.resize((3, )) a3.resize((3, )) xhat = np.array([1., 0., 0.]) yhat = np.array([0., 1., 0.]) zhat = np.array([0., 0., 1.]) # Find quaternion to rotate first lattice vector to x axis a1mag = np.sqrt(np.dot(a1, a1)) v1 = a1 / a1mag + xhat v1mag = np.sqrt(np.dot(v1, v1)) if v1mag > 1e-6: u1 = v1 / v1mag else: # a1 is antialigned with xhat, so rotate around any unit vector perpendicular to xhat u1 = yhat q1 = np.concatenate(([np.cos(np.pi / 2)], np.sin(np.pi / 2) * u1)) # Find quaternion to rotate second lattice vector to xy plane after applying above rotation a2prime = quatRot(q1, a2) angle = -1 * np.arctan2(a2prime[2], a2prime[1]) q2 = np.concatenate(([np.cos(angle / 2)], np.sin(angle / 2) * xhat)) q = quatMult(q2, q1) Lx = np.sqrt(np.dot(a1, a1)) a2x = np.dot(a1, a2) / Lx Ly = np.sqrt(np.dot(a2, a2) - a2x * a2x) xy = a2x / Ly v0xv1 = np.cross(a1, a2) v0xv1mag = np.sqrt(np.dot(v0xv1, v0xv1)) Lz = np.dot(a3, v0xv1) / v0xv1mag a3x = np.dot(a1, a3) / Lx xz = a3x / Lz yz = (np.dot(a2, a3) - a2x * a3x) / (Ly * Lz) box = boxdim(Lx=Lx, Ly=Ly, Lz=Lz, xy=xy, xz=xz, yz=yz, dimensions=ndim) return box, q
def compute_psi6_correlation_from_gsd(fpath, Nframes=1, frame_step=1, nxny=(100,100), init_frame=0): nx, ny = nxny cf_psi = np.zeros((ny, nx), dtype=complex) for frame in range(init_frame, init_frame + Nframes, frame_step): with gsd.fl.GSDFile(fpath, 'rb') as f_gsd: n_frames_total = f_gsd.nframes if frame > n_frames_total: print('frame {} beyond n_frames_total = {}'.format(frame, n_frames_total)) else: #translate negative indices into positive domain: abs_frame = frame -(frame//n_frames_total)*n_frames_total pos = f_gsd.read_chunk(frame=abs_frame, name='particles/position') box_array = f_gsd.read_chunk(frame=0, name='configuration/box') box = boxdim(*box_array[0:3]) psi = psi_order(pos, box, nx=nx, ny=ny, rcut=1.3) cf_psi += correlation_function(psi) cf_psi /= min(Nframes, n_frames_total) return cf_psi
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 pair_correlation_from_gsd(filename, n_bins = (100, 100), frames =(0, -1)): """ Calculate pair correlation function. Averaged over frames in the range from frames[0] to frames[1]. Negative frames are counted from the end of time. \param filename: name of the gsd file \param n_bins: tuple of size 2, numbers of bins in x and y direction for correlation function, both even Return: array of shape n_bins, pair correlation function normalized to (N - 1). Zero of coordinate is in the middle of the pixel grid (between pixels indexed (n_bins[i]/2 - 1) and (n_bins[i]/2)). """ try: if is_odd(n_bins[0]) or is_odd(n_bins[1]): raise ValueError("n_bins must be 2 x 1 tuple of even numbers") except: raise ValueError("n_bins must be 2 x 1 tuple of even numbers") g = np.zeros(n_bins) with gsd.fl.GSDFile(filename, 'rb') as f_gsd: n_frames_total = f_gsd.nframes if frames[0] > n_frames_total or frames[1] > n_frames_total: raise ValueError('frames beyond n_frames_total') #translate negative indices into positive domain: abs_frames = (frames[0] -(frames[0]//n_frames_total)*n_frames_total, \ frames[1] -(frames[1]//n_frames_total)*n_frames_total) if abs_frames[0] > abs_frames[1]: raise ValueError('frames[0] must be to the left from frames[1]') all_frames = np.arange(0, n_frames_total, 1) selected_frames = all_frames[abs_frames[0]:abs_frames[1] + 1] n_frames = abs_frames[1] - abs_frames[0] + 1 n_p = f_gsd.read_chunk(frame=0, name='particles/N') box_array = f_gsd.read_chunk(frame=0, name='configuration/box') box = boxdim(*box_array[0:3]) pos = np.zeros((n_frames, n_p[0], 2)) for j_frame in range(n_frames): pos_frame = f_gsd.read_chunk(frame=selected_frames[j_frame], name='particles/position') g += pair_correlation(pos_frame, box, n_bins = n_bins) g /= n_frames return g
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 plot_delone_triangulation(fpath, frame=0, fig=None, ax=None): with gsd.fl.GSDFile(fpath, 'rb') as f_gsd: n_frames_total = f_gsd.nframes if frame > n_frames_total: raise ValueError('frames beyond n_frames_total') #translate negative indices into positive domain: abs_frame = frame -(frame//n_frames_total)*n_frames_total pos = f_gsd.read_chunk(frame=abs_frame, name='particles/position') box_array = f_gsd.read_chunk(frame=0, name='configuration/box') box = boxdim(*box_array[0:3]) if ax==None or fig==None: fig = plt.figure(figsize = figsize) ax = fig.add_subplot(111, aspect='equal', autoscale_on=False, xlim=(-0.6*box.Lx, 0.6*box.Lx), ylim=(-0.6*box.Ly, 0.6*box.Ly)) xlim = (-0.5*box.Lx, 0.5*box.Lx) ylim = (-0.5*box.Ly, 0.5*box.Ly) virtual_pos, virtual_ind = create_virtual_layer(pos, box) tri = Delaunay(virtual_pos[:, 0:2]) ax.triplot(virtual_pos[:,0], virtual_pos[:,1], tri.simplices.copy(), color='black') ax.set_xlim(xlim) ax.set_ylim(ylim) return fig, ax
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 read_pos(fname, ndim=3): from hoomd.data import boxdim Lx = 0 Ly = 0 Lz = 0 xy = 0 xz = 0 yz = 0 f_in = open(fname) positions = [] # list of particle positions orientations = [] # list of particle orientations types = [] # list of particle types t_rs = {} # dictionary of position lists for defined particle types t_qs = {} # dictionary of orientation lists for defined particle types t_params = {} # additional particle parameters eof = 0 # count the number of frames for line in f_in: # get tokens on line tokens = line.split() if len(tokens) > 2: # definition line if re.match('^def', line) is not None: # get particle type definition t = tokens[1] # add new definitions t_rs[t] = [] t_qs[t] = [] t_params[t] = {} tokens[2] = tokens[2].split('"')[-1] tokens[-1] = tokens[-1].split('"')[0] shape = tokens[2] t_params[t]['shape'] = shape if shape == "poly3d": num_verts = int(tokens[3]) t_params[t]['verts'] = np.array([ float(n) for n in tokens[4:num_verts * 3 + 4] ]).reshape(num_verts, 3) if shape == "spoly3d": radius = float(tokens[3]) t_params[t]['radius'] = radius num_verts = int(tokens[4]) t_params[t]['verts'] = np.array([ float(n) for n in tokens[5:num_verts * 3 + 5] ]).reshape(num_verts, 3) if shape == "sphere": diameter = float(tokens[3]) t_params[t]['diameter'] = diameter if shape == "cyl": diameter = float(tokens[3]) t_params[t]['diameter'] = diameter t_params[t]['length'] = float(tokens[4]) if re.match('^box ', line) is not None: Lx = float(tokens[-3]) Ly = float(tokens[-2]) Lz = float(tokens[-1]) box = boxdim(Lx, Ly, Lz) q = np.array([1, 0, 0, 0]) elif re.match('^boxMatrix', line) is not None: # rotate the box matrix to be upper triangular pbox = np.array([float(f) for f in tokens[1:10]]).reshape(3, 3) a1 = pbox[:, 0] a2 = pbox[:, 1] a3 = pbox[:, 2] box, q = latticeToHoomd(a1, a2, a3, ndim) elif re.match('^eof', line) is not None: # clean up at the end of the frame eof += 1 positions = np.concatenate([t_rs[t] for t in t_rs]) orientations = np.concatenate([t_qs[t] for t in t_rs]) types = [] for t in t_rs: # build list of particle types with indices corresponding to other data structures types.extend([t] * len(t_rs[t])) # reset data structures for next frame t_rs = {} t_qs = {} # leave t_params intact... seems like the right thing to do else: for t in t_rs.keys(): if re.match('^{}'.format(t), line) is not None: # spheres don't have orientations in pos files if len(tokens) > 4: t_rs[t].append([float(f) for f in tokens[-7:-4]]) t_qs[t].append([float(f) for f in tokens[-4:]]) else: t_rs[t].append([float(f) for f in tokens[-3:]]) t_qs[t].append([1., 0, 0, 0]) # Try to recover from missing 'eof' string in single-frame files if eof == 0: positions = np.concatenate([t_rs[t] for t in t_rs]) orientations = np.concatenate([t_qs[t] for t in t_rs]) types = [] for t in t_rs: # build list of particle types with indices corresponding to other data structures types.extend([t] * len(t_rs[t])) if len(positions) == 0: raise ValueError( "No frames read from {}. Invalid pos file?".format(fname)) # rotate particles and positions, then wrap back into box just in case for i in range(len(positions)): positions[i] = quatRot(q, positions[i]) positions[i], img = box.wrap(positions[i]) orientations[i] = quatMult(q, orientations[i]) f_in.close() return { 'positions': positions, 'orientations': orientations, 'types': types, 'param_dict': t_params, 'box': box, 'q': q }
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 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_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 animate_gsd(fpath, savefile = None, periodic = False, center_fixed = True, interval = 100, figsize = (12, 12), rcut = 1.4,\ neighb = False): """ Create animation from a gsd file, where fpath is the path+filename to the gsd file. lx, ly - dimensions of the rectangular simulation box; savefile - filename for saving the animation. Not trying to save if the value is None; periodic - show with periodic boundary conditions if True, let particles migrate out of box if False; interval - time interval between frames in microseconds; return fig, ax """ def init(): scat.set_offsets(pos[0, :, :]) time_text.set_text('') return scat, time_text def update(frame_number): scat.set_offsets(pos[frame_number, :, :]) time_text.set_text('frame = {} of {}'.format(frame_number, n_frames)) if neighb: five_ind = np.where(neighbor_num[frame_number, :] == 5)[0] seven_ind = np.where(neighbor_num[frame_number, :] == 7)[0] five_scat.set_offsets(pos[frame_number, five_ind, :]) seven_scat.set_offsets(pos[frame_number, seven_ind, :]) else: five_scat.set_offsets(empty_pos) seven_scat.set_offsets(empty_pos) return scat, time_text, five_scat, seven_scat with gsd.fl.GSDFile(fpath, 'rb') as f_gsd: n_frames = f_gsd.nframes n_p = f_gsd.read_chunk(frame=0, name='particles/N') box = f_gsd.read_chunk(frame=0, name='configuration/box') pos = np.zeros((n_frames, n_p[0], 2)) neighbor_num = np.zeros((n_frames, int(n_p)), dtype = int) pos_frame = f_gsd.read_chunk(frame=0, name='particles/position') pos_frame_raw = pos_frame mean_pos_0 = np.mean(pos_frame, axis = 0) for j_frame in range(n_frames): pos_m1 = pos_frame pos_m1_raw = pos_frame_raw pos_frame_raw = f_gsd.read_chunk(frame=j_frame, name='particles/position') if not periodic: pos_frame = correct_jumps(pos_frame_raw, pos_m1, pos_m1_raw, box[0], box[1]) else: pos_frame = pos_frame_raw if center_fixed: pos_frame -= np.mean(pos_frame, axis = 0) - mean_pos_0 pos[j_frame, :, :] = pos_frame[:, 0:2] if neighb: boxdim_box = boxdim(box[0], box[1], box[2]) neighbor_list, neighbor_num[j_frame, :] = find_neighbors_delone(pos[j_frame, :,:], boxdim_box, rcut = rcut) fig = plt.figure(figsize = figsize) ax = fig.add_subplot(111, aspect='equal', autoscale_on=False, xlim=(-box[0], box[0]), ylim=(-box[1], box[1])) scat = ax.scatter(pos[0, :, 0], pos[0, :, 1], s = 3, facecolors='blue') empty_pos = np.zeros(0) if neighb: five_ind_0 = np.where(neighbor_num[0, :] == 5)[0] seven_ind_0 = np.where(neighbor_num[0, :] == 7)[0] seven_scat = ax.scatter(pos[0, seven_ind_0, 0], pos[0, seven_ind_0, 1], s = 5, facecolors='green') five_scat = ax.scatter(pos[0, five_ind_0, 0], pos[0, five_ind_0, 1], s = 5, facecolors='red') else: seven_scat = ax.scatter(empty_pos, empty_pos) five_scat = ax.scatter(empty_pos, empty_pos) time_text = ax.text(0.02, 1.05, '', transform=ax.transAxes) animation = FuncAnimation(fig, update, interval=interval, frames=n_frames, blit=True) if not savefile == None: try: animation.save(savefile, fps=30) except Exception as ee: print(ee) return fig, ax, animation
def read_pos(fname, ndim=3): from hoomd.data import boxdim Lx=0; Ly=0; Lz=0; xy=0; xz=0; yz=0; f_in = open(fname) positions=[] # list of particle positions orientations=[] # list of particle orientations types=[] # list of particle types t_rs={} # dictionary of position lists for defined particle types t_qs={} # dictionary of orientation lists for defined particle types t_params={} # additional particle parameters eof = 0 # count the number of frames for line in f_in: # get tokens on line tokens = line.split() if len(tokens)>2: # definition line if re.match('^def', line) is not None: # get particle type definition t = tokens[1] # add new definitions t_rs[t]=[] t_qs[t]=[] t_params[t]={} tokens[2]=tokens[2].split('"')[-1] tokens[-1]=tokens[-1].split('"')[0] shape = tokens[2] t_params[t]['shape'] = shape if shape == "poly3d": num_verts=int(tokens[3]) t_params[t]['verts']=np.array([float(n) for n in tokens[4:num_verts*3+4]]).reshape(num_verts,3) if shape == "spoly3d": radius = float(tokens[3]) t_params[t]['radius'] = radius num_verts = int(tokens[4]) t_params[t]['verts']=np.array([float(n) for n in tokens[5:num_verts*3+5]]).reshape(num_verts,3) if shape == "sphere": diameter = float(tokens[3]) t_params[t]['diameter'] = diameter if shape == "cyl": diameter = float(tokens[3]) t_params[t]['diameter'] = diameter t_params[t]['length'] = float(tokens[4]) if re.match('^box ', line) is not None: Lx=float(tokens[-3]) Ly=float(tokens[-2]) Lz=float(tokens[-1]) box = boxdim(Lx, Ly, Lz) q = np.array([1,0,0,0]) elif re.match('^boxMatrix',line) is not None: # rotate the box matrix to be upper triangular pbox=np.array([float(f) for f in tokens[1:10]]).reshape(3,3) a1 = pbox[:,0] a2 = pbox[:,1] a3 = pbox[:,2] box, q = latticeToHoomd(a1, a2, a3, ndim) elif re.match('^eof',line) is not None: # clean up at the end of the frame eof += 1 positions = np.concatenate([t_rs[t] for t in t_rs]) orientations = np.concatenate([t_qs[t] for t in t_rs]) types = [] for t in t_rs: # build list of particle types with indices corresponding to other data structures types.extend([t]*len(t_rs[t])) # reset data structures for next frame t_rs = {} t_qs = {} # leave t_params intact... seems like the right thing to do else: for t in t_rs.keys(): if re.match('^{}'.format(t), line) is not None: # spheres don't have orientations in pos files if len(tokens) > 4: t_rs[t].append([float(f) for f in tokens[-7:-4]]) t_qs[t].append([float(f) for f in tokens[-4:]]) else: t_rs[t].append([float(f) for f in tokens[-3:]]) t_qs[t].append([1.,0,0,0]) # Try to recover from missing 'eof' string in single-frame files if eof == 0: positions = np.concatenate([t_rs[t] for t in t_rs]) orientations = np.concatenate([t_qs[t] for t in t_rs]) types = [] for t in t_rs: # build list of particle types with indices corresponding to other data structures types.extend([t]*len(t_rs[t])) if len(positions) == 0: raise ValueError("No frames read from {}. Invalid pos file?".format(fname)) # rotate particles and positions, then wrap back into box just in case for i in range(len(positions)): positions[i] = quatRot(q, positions[i]) positions[i], img = box.wrap(positions[i]) orientations[i] = quatMult(q, orientations[i]) f_in.close() return {'positions':positions, 'orientations':orientations, 'types':types, 'param_dict':t_params, 'box':box, 'q':q}