|
|
|
|
@ -17,8 +17,8 @@ d = dump("dump.*") wildcard expands to multiple files
|
|
|
|
|
d = dump("dump.*",0) two args = store filenames, but don't read
|
|
|
|
|
|
|
|
|
|
incomplete and duplicate snapshots are deleted
|
|
|
|
|
if atoms have 5 or 8 columns, assign id,type,x,y,z (ix,iy,iz)
|
|
|
|
|
atoms will be unscaled if stored in files as scaled
|
|
|
|
|
self-describing column names assigned
|
|
|
|
|
|
|
|
|
|
time = d.next() read next snapshot from dump files
|
|
|
|
|
|
|
|
|
|
@ -28,7 +28,7 @@ time = d.next() read next snapshot from dump files
|
|
|
|
|
return -1 if no snapshots left or last snapshot is incomplete
|
|
|
|
|
no column name assignment or unscaling is performed
|
|
|
|
|
|
|
|
|
|
d.map(1,"id",3,"x") assign names to atom columns (1-N)
|
|
|
|
|
d.map(1,"id",3,"x") assign names to columns (1-N)
|
|
|
|
|
|
|
|
|
|
not needed if dump file is self-describing
|
|
|
|
|
|
|
|
|
|
@ -61,7 +61,7 @@ d.write("file",head,app) write selected steps/atoms to dump file
|
|
|
|
|
d.scatter("tmp") write selected steps/atoms to multiple files
|
|
|
|
|
|
|
|
|
|
write() can be specified with 2 additional flags
|
|
|
|
|
headd = 0/1 for no/yes snapshot header, app = 0/1 for write vs append
|
|
|
|
|
head = 0/1 for no/yes snapshot header, app = 0/1 for write vs append
|
|
|
|
|
scatter() files are given timestep suffix: e.g. tmp.0, tmp.100, etc
|
|
|
|
|
|
|
|
|
|
d.scale() scale x,y,z to 0-1 for all timesteps
|
|
|
|
|
@ -115,10 +115,9 @@ fx,fy,... = d.vecs(1000,"fx","fy",...) return vector(s) for timestep N
|
|
|
|
|
vecs() returns vectors with one value for each selected atom in the timestep
|
|
|
|
|
|
|
|
|
|
index,time,flag = d.iterator(0/1) loop over dump snapshots
|
|
|
|
|
time,box,atoms,bonds,tris = d.viz(index) return list of viz objects
|
|
|
|
|
time,box,atoms,bonds,tris,lines = d.viz(index) return list of viz objects
|
|
|
|
|
d.atype = "color" set column returned as "type" by viz
|
|
|
|
|
d.extra("dump.bond") read bond list from dump file
|
|
|
|
|
d.extra(data) extract bond/tri/line list from data
|
|
|
|
|
d.extra(obj) extract bond/tri/line info from obj
|
|
|
|
|
|
|
|
|
|
iterator() loops over selected timesteps
|
|
|
|
|
iterator() called with arg = 0 first time, with arg = 1 on subsequent calls
|
|
|
|
|
@ -126,17 +125,21 @@ d.extra(data) extract bond/tri/line list from data
|
|
|
|
|
time = timestep value
|
|
|
|
|
flag = -1 when iteration is done, 1 otherwise
|
|
|
|
|
viz() returns info for selected atoms for specified timestep index
|
|
|
|
|
can also call as viz(time,1) and will find index of preceding snapshot
|
|
|
|
|
time = timestep value
|
|
|
|
|
box = [xlo,ylo,zlo,xhi,yhi,zhi]
|
|
|
|
|
box = \[xlo,ylo,zlo,xhi,yhi,zhi\]
|
|
|
|
|
atoms = id,type,x,y,z for each atom as 2d array
|
|
|
|
|
bonds = id,type,x1,y1,z1,x2,y2,z2,t1,t2 for each bond as 2d array
|
|
|
|
|
if bonds() was used to define bonds, else empty list
|
|
|
|
|
if extra() used to define bonds, else NULL
|
|
|
|
|
tris = id,type,x1,y1,z1,x2,y2,z2,x3,y3,z3,nx,ny,nz for each tri as 2d array
|
|
|
|
|
if extra() was used to define tris, else empty list
|
|
|
|
|
if extra() used to define tris, else NULL
|
|
|
|
|
lines = id,type,x1,y1,z1,x2,y2,z2 for each line as 2d array
|
|
|
|
|
if extra() was used to define lines, else empty list
|
|
|
|
|
if extra() used to define lines, else NULL
|
|
|
|
|
atype is column name viz() will return as atom type (def = "type")
|
|
|
|
|
extra() stores list of bonds/tris/lines to return each time viz() is called
|
|
|
|
|
extra() extracts bonds/tris/lines from obj each time viz() is called
|
|
|
|
|
obj can be data object for bonds, cdata object for tris and lines,
|
|
|
|
|
bdump object for bonds, tdump object for tris, ldump object for lines.
|
|
|
|
|
mdump object for tris
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
# History
|
|
|
|
|
@ -153,6 +156,7 @@ d.extra(data) extract bond/tri/line list from data
|
|
|
|
|
# increment = 1 if reading snapshots one-at-a-time
|
|
|
|
|
# nextfile = which file to read from via next()
|
|
|
|
|
# eof = ptr into current file for where to read via next()
|
|
|
|
|
# scale_original = 0/1/-1 if coords were read in as unscaled/scaled/unknown
|
|
|
|
|
# nsnaps = # of snapshots
|
|
|
|
|
# nselect = # of selected snapshots
|
|
|
|
|
# snaps = list of snapshots
|
|
|
|
|
@ -161,20 +165,22 @@ d.extra(data) extract bond/tri/line list from data
|
|
|
|
|
# tselect = class for time selection
|
|
|
|
|
# aselect = class for atom selection
|
|
|
|
|
# atype = name of vector used as atom type by viz extract
|
|
|
|
|
# bondflag = 0 if no bonds, 1 if they are defined statically
|
|
|
|
|
# bondlist = static list of bonds to viz() return for all snapshots
|
|
|
|
|
# only a list of atom pairs, coords have to be created for each snapshot
|
|
|
|
|
# bondflag = 0 if no bonds, 1 if they are defined statically, 2 if dynamic
|
|
|
|
|
# bondlist = static list of bonds to return w/ viz() for all snapshots
|
|
|
|
|
# triflag = 0 if no tris, 1 if they are defined statically, 2 if dynamic
|
|
|
|
|
# trilist = static list of tris to return via viz() for all snapshots
|
|
|
|
|
# lineflag = 0 if no lines, 1 if they are defined statically
|
|
|
|
|
# linelist = static list of lines to return via viz() for all snapshots
|
|
|
|
|
# trilist = static list of tris to return w/ viz() for all snapshots
|
|
|
|
|
# lineflag = 0 if no lines, 1 if they are defined statically, 2 if dynamic
|
|
|
|
|
# linelist = static list of lines to return w/ viz() for all snapshots
|
|
|
|
|
# objextra = object to get bonds,tris,lines from dynamically
|
|
|
|
|
# Snap = one snapshot
|
|
|
|
|
# time = time stamp
|
|
|
|
|
# tselect = 0/1 if this snapshot selected
|
|
|
|
|
# natoms = # of atoms
|
|
|
|
|
# boxstr = format string after BOX BOUNDS, if it exists
|
|
|
|
|
# triclinic = 0/1 for orthogonal/triclinic based on BOX BOUNDS fields
|
|
|
|
|
# nselect = # of selected atoms in this snapshot
|
|
|
|
|
# aselect[i] = 0/1 for each atom
|
|
|
|
|
# xlo,xhi,ylo,yhi,zlo,zhi = box bounds (float)
|
|
|
|
|
# xlo,xhi,ylo,yhi,zlo,zhi,xy,xz,yz = box bounds (float)
|
|
|
|
|
# atoms[i][j] = 2d array of floats, i = 0 to natoms-1, j = 0 to ncols-1
|
|
|
|
|
|
|
|
|
|
# Imports and external programs
|
|
|
|
|
@ -184,11 +190,11 @@ from os import popen
|
|
|
|
|
from math import * # any function could be used by set()
|
|
|
|
|
|
|
|
|
|
try:
|
|
|
|
|
import numpy as np
|
|
|
|
|
oldnumeric = False
|
|
|
|
|
import numpy as np
|
|
|
|
|
oldnumeric = False
|
|
|
|
|
except:
|
|
|
|
|
import Numeric as np
|
|
|
|
|
oldnumeric = True
|
|
|
|
|
import Numeric as np
|
|
|
|
|
oldnumeric = True
|
|
|
|
|
|
|
|
|
|
try: from DEFAULTS import PIZZA_GUNZIP
|
|
|
|
|
except: PIZZA_GUNZIP = "gunzip"
|
|
|
|
|
@ -210,9 +216,9 @@ class dump:
|
|
|
|
|
self.bondlist = []
|
|
|
|
|
self.triflag = 0
|
|
|
|
|
self.trilist = []
|
|
|
|
|
self.triobj = 0
|
|
|
|
|
self.lineflag = 0
|
|
|
|
|
self.linelist = []
|
|
|
|
|
self.objextra = None
|
|
|
|
|
|
|
|
|
|
# flist = list of all dump file names
|
|
|
|
|
|
|
|
|
|
@ -263,19 +269,9 @@ class dump:
|
|
|
|
|
|
|
|
|
|
self.tselect.all()
|
|
|
|
|
|
|
|
|
|
# set default names for atom columns if file wasn't self-describing
|
|
|
|
|
# print column assignments
|
|
|
|
|
|
|
|
|
|
if len(self.snaps) == 0:
|
|
|
|
|
print "no column assignments made"
|
|
|
|
|
elif len(self.names):
|
|
|
|
|
print "assigned columns:",self.names2str()
|
|
|
|
|
elif self.snaps[0].atoms == None:
|
|
|
|
|
print "no column assignments made"
|
|
|
|
|
elif len(self.snaps[0].atoms[0]) == 5:
|
|
|
|
|
self.map(1,"id",2,"type",3,"x",4,"y",5,"z")
|
|
|
|
|
print "assigned columns:",self.names2str()
|
|
|
|
|
elif len(self.snaps[0].atoms[0]) == 8:
|
|
|
|
|
self.map(1,"id",2,"type",3,"x",4,"y",5,"z",6,"ix",7,"iy",8,"iz")
|
|
|
|
|
if len(self.names):
|
|
|
|
|
print "assigned columns:",self.names2str()
|
|
|
|
|
else:
|
|
|
|
|
print "no column assignments made"
|
|
|
|
|
@ -285,10 +281,11 @@ class dump:
|
|
|
|
|
if (not self.names.has_key("x")) or \
|
|
|
|
|
(not self.names.has_key("y")) or \
|
|
|
|
|
(not self.names.has_key("z")):
|
|
|
|
|
print "no unscaling could be performed"
|
|
|
|
|
print "dump scaling status is unknown"
|
|
|
|
|
elif self.nsnaps > 0:
|
|
|
|
|
if self.scaled(self.nsnaps-1): self.unscale()
|
|
|
|
|
else: print "dump is already unscaled"
|
|
|
|
|
if self.scale_original == 1: self.unscale()
|
|
|
|
|
elif self.scale_original == 0: print "dump is already unscaled"
|
|
|
|
|
else: print "dump scaling status is unknown"
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# read next snapshot from list of files
|
|
|
|
|
@ -333,8 +330,10 @@ class dump:
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# read a single snapshot from file f
|
|
|
|
|
# return snapshot or 0 if failed
|
|
|
|
|
# assign column names if not already done and file is self-describing
|
|
|
|
|
# convert xs,xu to x
|
|
|
|
|
# for first snapshot only:
|
|
|
|
|
# assign column names (file must be self-describing)
|
|
|
|
|
# set scale_original to 0/1/-1 for unscaled/scaled/unknown
|
|
|
|
|
# convert xs,xu to x in names
|
|
|
|
|
|
|
|
|
|
def read_snapshot(self,f):
|
|
|
|
|
try:
|
|
|
|
|
@ -347,26 +346,62 @@ class dump:
|
|
|
|
|
snap.aselect = np.zeros(snap.natoms)
|
|
|
|
|
|
|
|
|
|
item = f.readline()
|
|
|
|
|
words = item.split("BOUNDS ")
|
|
|
|
|
if len(words) == 1: snap.boxstr = ""
|
|
|
|
|
else: snap.boxstr = words[1].strip()
|
|
|
|
|
if "xy" in snap.boxstr: snap.triclinic = 1
|
|
|
|
|
else: snap.triclinic = 0
|
|
|
|
|
|
|
|
|
|
words = f.readline().split()
|
|
|
|
|
snap.xlo,snap.xhi = float(words[0]),float(words[1])
|
|
|
|
|
words = f.readline().split()
|
|
|
|
|
snap.ylo,snap.yhi = float(words[0]),float(words[1])
|
|
|
|
|
words = f.readline().split()
|
|
|
|
|
snap.zlo,snap.zhi = float(words[0]),float(words[1])
|
|
|
|
|
if len(words) == 2:
|
|
|
|
|
snap.xlo,snap.xhi,snap.xy = float(words[0]),float(words[1]),0.0
|
|
|
|
|
else:
|
|
|
|
|
snap.xlo,snap.xhi,snap.xy = \
|
|
|
|
|
float(words[0]),float(words[1]),float(words[2])
|
|
|
|
|
|
|
|
|
|
words = f.readline().split()
|
|
|
|
|
if len(words) == 2:
|
|
|
|
|
snap.ylo,snap.yhi,snap.xz = float(words[0]),float(words[1]),0.0
|
|
|
|
|
else:
|
|
|
|
|
snap.ylo,snap.yhi,snap.xz = \
|
|
|
|
|
float(words[0]),float(words[1]),float(words[2])
|
|
|
|
|
|
|
|
|
|
words = f.readline().split()
|
|
|
|
|
if len(words) == 2:
|
|
|
|
|
snap.zlo,snap.zhi,snap.yz = float(words[0]),float(words[1]),0.0
|
|
|
|
|
else:
|
|
|
|
|
snap.zlo,snap.zhi,snap.yz = \
|
|
|
|
|
float(words[0]),float(words[1]),float(words[2])
|
|
|
|
|
|
|
|
|
|
item = f.readline()
|
|
|
|
|
if len(self.names) == 0:
|
|
|
|
|
self.scale_original = -1
|
|
|
|
|
xflag = yflag = zflag = -1
|
|
|
|
|
words = item.split()[2:]
|
|
|
|
|
if len(words):
|
|
|
|
|
for i in range(len(words)):
|
|
|
|
|
if words[i] == "xs" or words[i] == "xu":
|
|
|
|
|
if words[i] == "x" or words[i] == "xu":
|
|
|
|
|
xflag = 0
|
|
|
|
|
self.names["x"] = i
|
|
|
|
|
elif words[i] == "ys" or words[i] == "yu":
|
|
|
|
|
elif words[i] == "xs" or words[i] == "xsu":
|
|
|
|
|
xflag = 1
|
|
|
|
|
self.names["x"] = i
|
|
|
|
|
elif words[i] == "y" or words[i] == "yu":
|
|
|
|
|
yflag = 0
|
|
|
|
|
self.names["y"] = i
|
|
|
|
|
elif words[i] == "zs" or words[i] == "zu":
|
|
|
|
|
elif words[i] == "ys" or words[i] == "ysu":
|
|
|
|
|
yflag = 1
|
|
|
|
|
self.names["y"] = i
|
|
|
|
|
elif words[i] == "z" or words[i] == "zu":
|
|
|
|
|
zflag = 0
|
|
|
|
|
self.names["z"] = i
|
|
|
|
|
elif words[i] == "zs" or words[i] == "zsu":
|
|
|
|
|
zflag = 1
|
|
|
|
|
self.names["z"] = i
|
|
|
|
|
else: self.names[words[i]] = i
|
|
|
|
|
|
|
|
|
|
if xflag == 0 and yflag == 0 and zflag == 0: self.scale_original = 0
|
|
|
|
|
if xflag == 1 and yflag == 1 and zflag == 1: self.scale_original = 1
|
|
|
|
|
|
|
|
|
|
if snap.natoms:
|
|
|
|
|
words = f.readline().split()
|
|
|
|
|
ncol = len(words)
|
|
|
|
|
@ -387,27 +422,6 @@ class dump:
|
|
|
|
|
except:
|
|
|
|
|
return 0
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# decide if snapshot i is scaled/unscaled from coords of first and last atom
|
|
|
|
|
|
|
|
|
|
def scaled(self,i):
|
|
|
|
|
ix = self.names["x"]
|
|
|
|
|
iy = self.names["y"]
|
|
|
|
|
iz = self.names["z"]
|
|
|
|
|
natoms = self.snaps[i].natoms
|
|
|
|
|
if natoms == 0: return 0
|
|
|
|
|
x1 = self.snaps[i].atoms[0][ix]
|
|
|
|
|
y1 = self.snaps[i].atoms[0][iy]
|
|
|
|
|
z1 = self.snaps[i].atoms[0][iz]
|
|
|
|
|
x2 = self.snaps[i].atoms[natoms-1][ix]
|
|
|
|
|
y2 = self.snaps[i].atoms[natoms-1][iy]
|
|
|
|
|
z2 = self.snaps[i].atoms[natoms-1][iz]
|
|
|
|
|
if x1 >= -0.1 and x1 <= 1.1 and y1 >= -0.1 and y1 <= 1.1 and \
|
|
|
|
|
z1 >= -0.1 and z1 <= 1.1 and x2 >= -0.1 and x2 <= 1.1 and \
|
|
|
|
|
y2 >= -0.1 and y2 <= 1.1 and z2 >= -0.1 and z2 <= 1.1:
|
|
|
|
|
return 1
|
|
|
|
|
else: return 0
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# map atom column names
|
|
|
|
|
|
|
|
|
|
@ -418,9 +432,8 @@ class dump:
|
|
|
|
|
j = i + 1
|
|
|
|
|
self.names[pairs[j]] = pairs[i]-1
|
|
|
|
|
|
|
|
|
|
# delete unselected snapshots
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# delete unselected snapshots
|
|
|
|
|
|
|
|
|
|
def delete(self):
|
|
|
|
|
ndel = i = 0
|
|
|
|
|
@ -435,6 +448,7 @@ class dump:
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# scale coords to 0-1 for all snapshots or just one
|
|
|
|
|
# use 6 params as h-matrix to treat orthongonal or triclinic boxes
|
|
|
|
|
|
|
|
|
|
def scale(self,*list):
|
|
|
|
|
if len(list) == 0:
|
|
|
|
|
@ -453,17 +467,52 @@ class dump:
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
def scale_one(self,snap,x,y,z):
|
|
|
|
|
if snap.atoms == None: return
|
|
|
|
|
xprdinv = 1.0 / (snap.xhi - snap.xlo)
|
|
|
|
|
yprdinv = 1.0 / (snap.yhi - snap.ylo)
|
|
|
|
|
zprdinv = 1.0 / (snap.zhi - snap.zlo)
|
|
|
|
|
atoms = snap.atoms
|
|
|
|
|
atoms[:,x] = (atoms[:,x] - snap.xlo) * xprdinv
|
|
|
|
|
atoms[:,y] = (atoms[:,y] - snap.ylo) * yprdinv
|
|
|
|
|
atoms[:,z] = (atoms[:,z] - snap.zlo) * zprdinv
|
|
|
|
|
|
|
|
|
|
if snap.xy == 0.0 and snap.xz == 0.0 and snap.yz == 0.0:
|
|
|
|
|
xprdinv = 1.0 / (snap.xhi - snap.xlo)
|
|
|
|
|
yprdinv = 1.0 / (snap.yhi - snap.ylo)
|
|
|
|
|
zprdinv = 1.0 / (snap.zhi - snap.zlo)
|
|
|
|
|
atoms = snap.atoms
|
|
|
|
|
if atoms != None:
|
|
|
|
|
atoms[:,x] = (atoms[:,x] - snap.xlo) * xprdinv
|
|
|
|
|
atoms[:,y] = (atoms[:,y] - snap.ylo) * yprdinv
|
|
|
|
|
atoms[:,z] = (atoms[:,z] - snap.zlo) * zprdinv
|
|
|
|
|
else:
|
|
|
|
|
xlo_bound = snap.xlo; xhi_bound = snap.xhi
|
|
|
|
|
ylo_bound = snap.ylo; yhi_bound = snap.yhi
|
|
|
|
|
zlo_bound = snap.zlo; zhi_bound = snap.zhi
|
|
|
|
|
xy = snap.xy
|
|
|
|
|
xz = snap.xz
|
|
|
|
|
yz = snap.yz
|
|
|
|
|
xlo = xlo_bound - min((0.0,xy,xz,xy+xz))
|
|
|
|
|
xhi = xhi_bound - max((0.0,xy,xz,xy+xz))
|
|
|
|
|
ylo = ylo_bound - min((0.0,yz))
|
|
|
|
|
yhi = yhi_bound - max((0.0,yz))
|
|
|
|
|
zlo = zlo_bound
|
|
|
|
|
zhi = zhi_bound
|
|
|
|
|
h0 = xhi - xlo
|
|
|
|
|
h1 = yhi - ylo
|
|
|
|
|
h2 = zhi - zlo
|
|
|
|
|
h3 = yz
|
|
|
|
|
h4 = xz
|
|
|
|
|
h5 = xy
|
|
|
|
|
h0inv = 1.0 / h0
|
|
|
|
|
h1inv = 1.0 / h1
|
|
|
|
|
h2inv = 1.0 / h2
|
|
|
|
|
h3inv = yz / (h1*h2)
|
|
|
|
|
h4inv = (h3*h5 - h1*h4) / (h0*h1*h2)
|
|
|
|
|
h5inv = xy / (h0*h1)
|
|
|
|
|
atoms = snap.atoms
|
|
|
|
|
if atoms != None:
|
|
|
|
|
atoms[:,x] = (atoms[:,x] - snap.xlo)*h0inv + \
|
|
|
|
|
(atoms[:,y] - snap.ylo)*h5inv + \
|
|
|
|
|
(atoms[:,z] - snap.zlo)*h4inv
|
|
|
|
|
atoms[:,y] = (atoms[:,y] - snap.ylo)*h1inv + \
|
|
|
|
|
(atoms[:,z] - snap.zlo)*h3inv
|
|
|
|
|
atoms[:,z] = (atoms[:,z] - snap.zlo)*h2inv
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# unscale coords from 0-1 to box size for all snapshots or just one
|
|
|
|
|
# use 6 params as h-matrix to treat orthongonal or triclinic boxes
|
|
|
|
|
|
|
|
|
|
def unscale(self,*list):
|
|
|
|
|
if len(list) == 0:
|
|
|
|
|
@ -482,15 +531,40 @@ class dump:
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
def unscale_one(self,snap,x,y,z):
|
|
|
|
|
if snap.atoms == None: return
|
|
|
|
|
xprd = snap.xhi - snap.xlo
|
|
|
|
|
yprd = snap.yhi - snap.ylo
|
|
|
|
|
zprd = snap.zhi - snap.zlo
|
|
|
|
|
atoms = snap.atoms
|
|
|
|
|
atoms[:,x] = snap.xlo + atoms[:,x]*xprd
|
|
|
|
|
atoms[:,y] = snap.ylo + atoms[:,y]*yprd
|
|
|
|
|
atoms[:,z] = snap.zlo + atoms[:,z]*zprd
|
|
|
|
|
|
|
|
|
|
if snap.xy == 0.0 and snap.xz == 0.0 and snap.yz == 0.0:
|
|
|
|
|
xprd = snap.xhi - snap.xlo
|
|
|
|
|
yprd = snap.yhi - snap.ylo
|
|
|
|
|
zprd = snap.zhi - snap.zlo
|
|
|
|
|
atoms = snap.atoms
|
|
|
|
|
if atoms != None:
|
|
|
|
|
atoms[:,x] = snap.xlo + atoms[:,x]*xprd
|
|
|
|
|
atoms[:,y] = snap.ylo + atoms[:,y]*yprd
|
|
|
|
|
atoms[:,z] = snap.zlo + atoms[:,z]*zprd
|
|
|
|
|
else:
|
|
|
|
|
xlo_bound = snap.xlo; xhi_bound = snap.xhi
|
|
|
|
|
ylo_bound = snap.ylo; yhi_bound = snap.yhi
|
|
|
|
|
zlo_bound = snap.zlo; zhi_bound = snap.zhi
|
|
|
|
|
xy = snap.xy
|
|
|
|
|
xz = snap.xz
|
|
|
|
|
yz = snap.yz
|
|
|
|
|
xlo = xlo_bound - min((0.0,xy,xz,xy+xz))
|
|
|
|
|
xhi = xhi_bound - max((0.0,xy,xz,xy+xz))
|
|
|
|
|
ylo = ylo_bound - min((0.0,yz))
|
|
|
|
|
yhi = yhi_bound - max((0.0,yz))
|
|
|
|
|
zlo = zlo_bound
|
|
|
|
|
zhi = zhi_bound
|
|
|
|
|
h0 = xhi - xlo
|
|
|
|
|
h1 = yhi - ylo
|
|
|
|
|
h2 = zhi - zlo
|
|
|
|
|
h3 = yz
|
|
|
|
|
h4 = xz
|
|
|
|
|
h5 = xy
|
|
|
|
|
atoms = snap.atoms
|
|
|
|
|
if atoms != None:
|
|
|
|
|
atoms[:,x] = snap.xlo + atoms[:,x]*h0 + atoms[:,y]*h5 + atoms[:,z]*h4
|
|
|
|
|
atoms[:,y] = snap.ylo + atoms[:,y]*h1 + atoms[:,z]*h3
|
|
|
|
|
atoms[:,z] = snap.zlo + atoms[:,z]*h2
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# wrap coords from outside box to inside
|
|
|
|
|
|
|
|
|
|
@ -537,7 +611,8 @@ class dump:
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# wrap coords to same image as atom ID stored in "other" column
|
|
|
|
|
|
|
|
|
|
# if dynamic extra lines or triangles defined, owrap them as well
|
|
|
|
|
|
|
|
|
|
def owrap(self,other):
|
|
|
|
|
print "Wrapping to other ..."
|
|
|
|
|
|
|
|
|
|
@ -549,7 +624,7 @@ class dump:
|
|
|
|
|
iy = self.names["iy"]
|
|
|
|
|
iz = self.names["iz"]
|
|
|
|
|
iother = self.names[other]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for snap in self.snaps:
|
|
|
|
|
xprd = snap.xhi - snap.xlo
|
|
|
|
|
yprd = snap.yhi - snap.ylo
|
|
|
|
|
@ -563,14 +638,17 @@ class dump:
|
|
|
|
|
atoms[i][x] += (atoms[i][ix]-atoms[j][ix])*xprd
|
|
|
|
|
atoms[i][y] += (atoms[i][iy]-atoms[j][iy])*yprd
|
|
|
|
|
atoms[i][z] += (atoms[i][iz]-atoms[j][iz])*zprd
|
|
|
|
|
|
|
|
|
|
# should bonds also be owrapped ?
|
|
|
|
|
if self.lineflag == 2 or self.triflag == 2:
|
|
|
|
|
self.objextra.owrap(snap.time,xprd,yprd,zprd,ids,atoms,iother,ix,iy,iz)
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# convert column names assignment to a string, in column order
|
|
|
|
|
|
|
|
|
|
def names2str(self):
|
|
|
|
|
ncol = len(self.snaps[0].atoms[0])
|
|
|
|
|
pairs = self.names.items()
|
|
|
|
|
values = self.names.values()
|
|
|
|
|
ncol = len(pairs)
|
|
|
|
|
str = ""
|
|
|
|
|
for i in xrange(ncol):
|
|
|
|
|
if i in values: str += pairs[values.index(i)][0] + ' '
|
|
|
|
|
@ -614,6 +692,12 @@ class dump:
|
|
|
|
|
if len(self.snaps): namestr = self.names2str()
|
|
|
|
|
if not append: f = open(file,"w")
|
|
|
|
|
else: f = open(file,"a")
|
|
|
|
|
|
|
|
|
|
if "id" in self.names: id = self.names["id"]
|
|
|
|
|
else: id = -1
|
|
|
|
|
if "type" in self.names: type = self.names["type"]
|
|
|
|
|
else: type = -1
|
|
|
|
|
|
|
|
|
|
for snap in self.snaps:
|
|
|
|
|
if not snap.tselect: continue
|
|
|
|
|
print snap.time,
|
|
|
|
|
@ -624,10 +708,16 @@ class dump:
|
|
|
|
|
print >>f,snap.time
|
|
|
|
|
print >>f,"ITEM: NUMBER OF ATOMS"
|
|
|
|
|
print >>f,snap.nselect
|
|
|
|
|
print >>f,"ITEM: BOX BOUNDS"
|
|
|
|
|
print >>f,snap.xlo,snap.xhi
|
|
|
|
|
print >>f,snap.ylo,snap.yhi
|
|
|
|
|
print >>f,snap.zlo,snap.zhi
|
|
|
|
|
if snap.boxstr: print >>f,"ITEM: BOX BOUNDS",snap.boxstr
|
|
|
|
|
else: print >>f,"ITEM: BOX BOUNDS"
|
|
|
|
|
if snap.triclinic:
|
|
|
|
|
print >>f,snap.xlo,snap.xhi,snap.xy
|
|
|
|
|
print >>f,snap.ylo,snap.yhi,snap.xz
|
|
|
|
|
print >>f,snap.zlo,snap.zhi,snap.yz
|
|
|
|
|
else:
|
|
|
|
|
print >>f,snap.xlo,snap.xhi
|
|
|
|
|
print >>f,snap.ylo,snap.yhi
|
|
|
|
|
print >>f,snap.zlo,snap.zhi
|
|
|
|
|
print >>f,"ITEM: ATOMS",namestr
|
|
|
|
|
|
|
|
|
|
atoms = snap.atoms
|
|
|
|
|
@ -636,7 +726,7 @@ class dump:
|
|
|
|
|
if not snap.aselect[i]: continue
|
|
|
|
|
line = ""
|
|
|
|
|
for j in xrange(nvalues):
|
|
|
|
|
if (j < 2):
|
|
|
|
|
if j == id or j == type:
|
|
|
|
|
line += str(int(atoms[i][j])) + " "
|
|
|
|
|
else:
|
|
|
|
|
line += str(atoms[i][j]) + " "
|
|
|
|
|
@ -660,10 +750,16 @@ class dump:
|
|
|
|
|
print >>f,snap.time
|
|
|
|
|
print >>f,"ITEM: NUMBER OF ATOMS"
|
|
|
|
|
print >>f,snap.nselect
|
|
|
|
|
print >>f,"ITEM: BOX BOUNDS"
|
|
|
|
|
print >>f,snap.xlo,snap.xhi
|
|
|
|
|
print >>f,snap.ylo,snap.yhi
|
|
|
|
|
print >>f,snap.zlo,snap.zhi
|
|
|
|
|
if snap.boxstr: print >>f,"ITEM: BOX BOUNDS",snap.boxstr
|
|
|
|
|
else: print >>f,"ITEM: BOX BOUNDS"
|
|
|
|
|
if snap.triclinic:
|
|
|
|
|
print >>f,snap.xlo,snap.xhi,snap.xy
|
|
|
|
|
print >>f,snap.ylo,snap.yhi,snap.xz
|
|
|
|
|
print >>f,snap.zlo,snap.zhi,snap.yz
|
|
|
|
|
else:
|
|
|
|
|
print >>f,snap.xlo,snap.xhi
|
|
|
|
|
print >>f,snap.ylo,snap.yhi
|
|
|
|
|
print >>f,snap.zlo,snap.zhi
|
|
|
|
|
print >>f,"ITEM: ATOMS",namestr
|
|
|
|
|
|
|
|
|
|
atoms = snap.atoms
|
|
|
|
|
@ -897,9 +993,20 @@ class dump:
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# return list of atoms to viz for snapshot isnap
|
|
|
|
|
# if called with flag, then index is timestep, so convert to snapshot index
|
|
|
|
|
# augment with bonds, tris, lines if extra() was invoked
|
|
|
|
|
|
|
|
|
|
def viz(self,isnap):
|
|
|
|
|
def viz(self,index,flag=0):
|
|
|
|
|
if not flag: isnap = index
|
|
|
|
|
else:
|
|
|
|
|
times = self.time()
|
|
|
|
|
n = len(times)
|
|
|
|
|
i = 0
|
|
|
|
|
while i < n:
|
|
|
|
|
if times[i] > index: break
|
|
|
|
|
i += 1
|
|
|
|
|
isnap = i - 1
|
|
|
|
|
|
|
|
|
|
snap = self.snaps[isnap]
|
|
|
|
|
|
|
|
|
|
time = snap.time
|
|
|
|
|
@ -919,18 +1026,22 @@ class dump:
|
|
|
|
|
atom = snap.atoms[i]
|
|
|
|
|
atoms.append([atom[id],atom[type],atom[x],atom[y],atom[z]])
|
|
|
|
|
|
|
|
|
|
# create list of current bond coords from static bondlist
|
|
|
|
|
# create list of bonds from static or dynamic bond list
|
|
|
|
|
# then generate bond coords from bondlist
|
|
|
|
|
# alist = dictionary of atom IDs for atoms list
|
|
|
|
|
# lookup bond atom IDs in alist and grab their coords
|
|
|
|
|
# try is used since some atoms may be unselected
|
|
|
|
|
# any bond with unselected atom is not returned to viz caller
|
|
|
|
|
# any bond with unselected atom is not added to bonds
|
|
|
|
|
# need Numeric/Numpy mode here
|
|
|
|
|
|
|
|
|
|
bonds = []
|
|
|
|
|
if self.bondflag:
|
|
|
|
|
if self.bondflag == 1: bondlist = self.bondlist
|
|
|
|
|
elif self.bondflag == 2:
|
|
|
|
|
tmp1,tmp2,tmp3,bondlist,tmp4,tmp5 = self.objextra.viz(time,1)
|
|
|
|
|
alist = {}
|
|
|
|
|
for i in xrange(len(atoms)): alist[int(atoms[i][0])] = i
|
|
|
|
|
for bond in self.bondlist:
|
|
|
|
|
for bond in bondlist:
|
|
|
|
|
try:
|
|
|
|
|
i = alist[bond[2]]
|
|
|
|
|
j = alist[bond[3]]
|
|
|
|
|
@ -940,15 +1051,23 @@ class dump:
|
|
|
|
|
atom2[2],atom2[3],atom2[4],atom1[1],atom2[1]])
|
|
|
|
|
except: continue
|
|
|
|
|
|
|
|
|
|
# create list of tris from static or dynamic tri list
|
|
|
|
|
# if dynamic, could eliminate tris for unselected atoms
|
|
|
|
|
|
|
|
|
|
tris = []
|
|
|
|
|
if self.triflag:
|
|
|
|
|
if self.triflag == 1: tris = self.trilist
|
|
|
|
|
elif self.triflag == 2:
|
|
|
|
|
timetmp,boxtmp,atomstmp,bondstmp, \
|
|
|
|
|
tris,linestmp = self.triobj.viz(time,1)
|
|
|
|
|
|
|
|
|
|
tmp1,tmp2,tmp3,tmp4,tris,tmp5 = self.objextra.viz(time,1)
|
|
|
|
|
|
|
|
|
|
# create list of lines from static or dynamic tri list
|
|
|
|
|
# if dynamic, could eliminate lines for unselected atoms
|
|
|
|
|
|
|
|
|
|
lines = []
|
|
|
|
|
if self.lineflag: lines = self.linelist
|
|
|
|
|
if self.lineflag:
|
|
|
|
|
if self.lineflag == 1: lines = self.linelist
|
|
|
|
|
elif self.lineflag == 2:
|
|
|
|
|
tmp1,tmp2,tmp3,tmp4,tmp5,lines = self.objextra.viz(time,1)
|
|
|
|
|
|
|
|
|
|
return time,box,atoms,bonds,tris,lines
|
|
|
|
|
|
|
|
|
|
@ -991,49 +1110,14 @@ class dump:
|
|
|
|
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
# grab bonds/tris/lines from another object
|
|
|
|
|
# if static, grab once, else store obj to grab dynamically
|
|
|
|
|
|
|
|
|
|
def extra(self,arg):
|
|
|
|
|
|
|
|
|
|
# read bonds from bond dump file
|
|
|
|
|
# data object, grab bonds statically
|
|
|
|
|
|
|
|
|
|
if type(arg) is types.StringType:
|
|
|
|
|
try:
|
|
|
|
|
f = open(arg,'r')
|
|
|
|
|
|
|
|
|
|
item = f.readline()
|
|
|
|
|
time = int(f.readline())
|
|
|
|
|
item = f.readline()
|
|
|
|
|
nbonds = int(f.readline())
|
|
|
|
|
item = f.readline()
|
|
|
|
|
if not re.search("BONDS",item):
|
|
|
|
|
raise StandardError, "could not read bonds from dump file"
|
|
|
|
|
|
|
|
|
|
words = f.readline().split()
|
|
|
|
|
ncol = len(words)
|
|
|
|
|
for i in xrange(1,nbonds):
|
|
|
|
|
words += f.readline().split()
|
|
|
|
|
f.close()
|
|
|
|
|
|
|
|
|
|
# convert values to int and absolute value since can be negative types
|
|
|
|
|
|
|
|
|
|
if oldnumeric: bondlist = np.zeros((nbonds,4),np.Int)
|
|
|
|
|
else: bondlist = np.zeros((nbonds,4),np.int)
|
|
|
|
|
ints = [abs(int(value)) for value in words]
|
|
|
|
|
start = 0
|
|
|
|
|
stop = 4
|
|
|
|
|
for i in xrange(nbonds):
|
|
|
|
|
bondlist[i] = ints[start:stop]
|
|
|
|
|
start += ncol
|
|
|
|
|
stop += ncol
|
|
|
|
|
if bondlist:
|
|
|
|
|
self.bondflag = 1
|
|
|
|
|
self.bondlist = bondlist
|
|
|
|
|
except:
|
|
|
|
|
raise StandardError,"could not read from bond dump file"
|
|
|
|
|
|
|
|
|
|
# request bonds from data object
|
|
|
|
|
|
|
|
|
|
elif type(arg) is types.InstanceType and ".data" in str(arg.__class__):
|
|
|
|
|
if type(arg) is types.InstanceType and ".data" in str(arg.__class__):
|
|
|
|
|
self.bondflag = 0
|
|
|
|
|
try:
|
|
|
|
|
bondlist = []
|
|
|
|
|
bondlines = arg.sections["Bonds"]
|
|
|
|
|
@ -1047,9 +1131,10 @@ class dump:
|
|
|
|
|
except:
|
|
|
|
|
raise StandardError,"could not extract bonds from data object"
|
|
|
|
|
|
|
|
|
|
# request tris/lines from cdata object
|
|
|
|
|
# cdata object, grab tris and lines statically
|
|
|
|
|
|
|
|
|
|
elif type(arg) is types.InstanceType and ".cdata" in str(arg.__class__):
|
|
|
|
|
self.triflag = self.lineflag = 0
|
|
|
|
|
try:
|
|
|
|
|
tmp,tmp,tmp,tmp,tris,lines = arg.viz(0)
|
|
|
|
|
if tris:
|
|
|
|
|
@ -1061,14 +1146,29 @@ class dump:
|
|
|
|
|
except:
|
|
|
|
|
raise StandardError,"could not extract tris/lines from cdata object"
|
|
|
|
|
|
|
|
|
|
# request tris from mdump object
|
|
|
|
|
# mdump object, grab tris dynamically
|
|
|
|
|
|
|
|
|
|
elif type(arg) is types.InstanceType and ".mdump" in str(arg.__class__):
|
|
|
|
|
try:
|
|
|
|
|
self.triflag = 2
|
|
|
|
|
self.triobj = arg
|
|
|
|
|
except:
|
|
|
|
|
raise StandardError,"could not extract tris from mdump object"
|
|
|
|
|
self.triflag = 2
|
|
|
|
|
self.objextra = arg
|
|
|
|
|
|
|
|
|
|
# bdump object, grab bonds dynamically
|
|
|
|
|
|
|
|
|
|
elif type(arg) is types.InstanceType and ".bdump" in str(arg.__class__):
|
|
|
|
|
self.bondflag = 2
|
|
|
|
|
self.objextra = arg
|
|
|
|
|
|
|
|
|
|
# ldump object, grab lines dynamically
|
|
|
|
|
|
|
|
|
|
elif type(arg) is types.InstanceType and ".ldump" in str(arg.__class__):
|
|
|
|
|
self.lineflag = 2
|
|
|
|
|
self.objextra = arg
|
|
|
|
|
|
|
|
|
|
# tdump object, grab tris dynamically
|
|
|
|
|
|
|
|
|
|
elif type(arg) is types.InstanceType and ".tdump" in str(arg.__class__):
|
|
|
|
|
self.triflag = 2
|
|
|
|
|
self.objextra = arg
|
|
|
|
|
|
|
|
|
|
else:
|
|
|
|
|
raise StandardError,"unrecognized argument to dump.extra()"
|
|
|
|
|
|
Axel Kohlmeyer