def main(argv):
'''
Thetrahedral Order Parameter calculation for a statefile produced with LAMMPS.
The state file has to be consisting of water only. The program will search for
atoms of type = Type only, and calculate the orderparameter according to the four
nearest atoms of type = Type.
TetrahedralParameter is dependent on os,numpy and displacement (made by goran)
'''
filetoread, Type, showplot,saveplot, outputfilename, temperature = cmdinfo(argv)
t, Natoms, system_size, matrix, readstructure, entries,types = readfile(filetoread)
today = datetime.date.today()
writetofile = outputfilename + "_plotdate_" + str(today) + ".dat"
ofile = open(writetofile,'w')
fourNearest(ofile,Natoms,matrix,Type,outputfilename,temperature,showplot,saveplot)
def storefileinfo(Time,Natoms,frontname,pathtodatabase):
print "##############################################################"
print "# Processing input files. Storing information in grand matrix"
print "#\n"
grandmatrix = []
for time in Time:
path = frontname + '.%r.txt' % (time)
print "# Processing file: %s " % path
filename = os.path.abspath(os.path.join(pathtodatabase,path))
t, Natoms, system_size, matrix, readstructure, entries, types = readfile(filename) # this takes time processing !!
info = []
for i in range(Natoms):
atom = [matrix['id'][i],matrix['type'][i], matrix['x'][i],matrix['y'][i],matrix['z'][i]]
info.append(atom)
grandmatrix.append(info)
print "##############################################################"
print "# Done processing..."
return grandmatrix
def simplecalc(frontname, database, initialmx, Natoms, Time, systemsize):
Lx = systemsize[1] - systemsize[0]
Ly = systemsize[3] - systemsize[2]
Lz = systemsize[5] - systemsize[4]
halfsystemsize = 0.5 * (Lx + Ly + Lz) / 3.0 # half of average system size
rsquared = 0
msd = []
for t in Time:
name = frontname + '.%r.txt' % t
filename = os.path.abspath(os.path.join(database, name))
time, Natoms, system_size, mx, readstructure, entries, types = readfile(
filename)
Noxygen = 0
for i in range(Natoms):
if (mx['type'][i] == 1):
for j in range(Natoms):
if (initialmx['id'][j] == mx['id'][i]):
dx = mx['x'][i] - initialmx['x'][j]
dy = mx['y'][i] - initialmx['y'][j]
dz = mx['z'][i] - initialmx['z'][j]
########################################
# MINIMUM IMAGE CONVENTION #
if (dx < -halfsystemsize): dx = dx + Lx
if (dx > halfsystemsize): dx = dx - Lx
if (dy < -halfsystemsize): dy = dy + Ly
if (dy > halfsystemsize): dy = dy - Ly
if (dz < -halfsystemsize): dz = dz + Lz
if (dz > halfsystemsize): dz = dz - Lz
########################################
dr2 = dx * dx + dy * dy + dz * dz
Noxygen += 1
rsquared += dr2
msd.append(rsquared / Noxygen)
plt.figure()
plt.plot(Time, msd)
plt.show()
def main(argv):
'''
Thetrahedral Order Parameter calculation for a statefile produced with LAMMPS.
The state file has to be consisting of water only. The program will search for
atoms of type = Type only, and calculate the orderparameter according to the four
nearest atoms of type = Type.
TetrahedralParameter is dependent on os,numpy and displacement (made by goran)
'''
filetoread, Type, showplot, saveplot, outputfilename, temperature = cmdinfo(
argv)
t, Natoms, system_size, matrix, readstructure, entries, types = readfile(
filetoread)
today = datetime.date.today()
writetofile = outputfilename + "_plotdate_" + str(today) + ".dat"
ofile = open(writetofile, 'w')
fourNearest(ofile, Natoms, matrix, Type, outputfilename, temperature,
showplot, saveplot)
def simplecalc(frontname,database,initialmx,Natoms,Time,systemsize):
Lx = systemsize[1] -systemsize[0]
Ly = systemsize[3] -systemsize[2]
Lz = systemsize[5] -systemsize[4]
halfsystemsize = 0.5*(Lx+Ly+Lz)/3.0 # half of average system size
rsquared = 0
msd = []
for t in Time:
name = frontname + '.%r.txt' % t
filename = os.path.abspath(os.path.join(database,name))
time,Natoms,system_size,mx,readstructure,entries,types = readfile(filename)
Noxygen = 0
for i in range(Natoms):
if (mx['type'][i] == 1):
for j in range(Natoms):
if (initialmx['id'][j] == mx['id'][i]):
dx = mx['x'][i] - initialmx['x'][j]
dy = mx['y'][i] - initialmx['y'][j]
dz = mx['z'][i] - initialmx['z'][j]
########################################
# MINIMUM IMAGE CONVENTION #
if (dx < -halfsystemsize): dx = dx + Lx
if (dx > halfsystemsize): dx = dx - Lx
if (dy < -halfsystemsize): dy = dy + Ly
if (dy > halfsystemsize): dy = dy - Ly
if (dz < -halfsystemsize): dz = dz + Lz
if (dz > halfsystemsize): dz = dz - Lz
########################################
dr2 = dx*dx + dy*dy + dz*dz
Noxygen += 1
rsquared += dr2
msd.append(rsquared/Noxygen)
plt.figure()
plt.plot(Time,msd)
plt.show()
def storefileinfo(Time, Natoms, frontname, pathtodatabase):
print "##############################################################"
print "# Processing input files. Storing information in grand matrix"
print "#\n"
grandmatrix = []
for time in Time:
path = frontname + '.%r.txt' % (time)
print "# Processing file: %s " % path
filename = os.path.abspath(os.path.join(pathtodatabase, path))
t, Natoms, system_size, matrix, readstructure, entries, types = readfile(
filename) # this takes time processing !!
info = []
for i in range(Natoms):
atom = [
matrix['id'][i], matrix['type'][i], matrix['x'][i],
matrix['y'][i], matrix['z'][i]
]
info.append(atom)
grandmatrix.append(info)
print "##############################################################"
print "# Done processing..."
return grandmatrix
def displacement(ofile,timestep,Natoms,matrix0,Type,Time,frontname,pathtodatabase,systemsize):
'''
timestep,system_size,matrix0 contain the initial information about the system.
we have to go through sortedfiles to find information about the particles at
later timesteps.
'''
factor = 10**(-8) # conversionfactor from [A^2/ps] -> [m^2/s]
Lx = systemsize[1] -systemsize[0]
Ly = systemsize[3] -systemsize[2]
Lz = systemsize[5] -systemsize[4]
halfsystemsize = 0.5*(Lx+Ly+Lz)/3.0 # half of average system size
time = []
for t in Time:
time.append(timestep*t/1000.0) # to picoseconds
#time.append(t)
MSDX = [];MSDY = [];MSDZ = [];MSD = [];D_local = []
dt = (time[1]-time[0])
for T in Time:
path = frontname + '.%r.txt' % (T)
print path
msdx = 0; msdy = 0; msdz = 0; msd = 0
filename = os.path.abspath(os.path.join(pathtodatabase,path))
t, Natoms, system_size, matrix, readstructure, entries, types = readfile(filename)
counter = 0
for i in range(Natoms):
if (matrix['type'][i] == Type):
ID = matrix['id'][i]
initial_index = None
for j in range(Natoms):
k = matrix0['id'][j]
if (k == ID):
initial_index = j
break
dx = matrix['x'][i] - matrix0['x'][initial_index]
dy = matrix['y'][i] - matrix0['y'][initial_index]
dz = matrix['z'][i] - matrix0['z'][initial_index]
msdx += (dx)**2
msdy += (dy)**2
msdz += (dz)**2
########################################
# MINIMUM IMAGE CONVENTION #
if (dx < -halfsystemsize): dx = dx + Lx
if (dx > halfsystemsize): dx = dx - Lx
if (dy < -halfsystemsize): dy = dy + Ly
if (dy > halfsystemsize): dy = dy - Ly
if (dz < -halfsystemsize): dz = dz + Lz
if (dz > halfsystemsize): dz = dz - Lz
########################################
msd += dx**2 + dy**2 + dz**2
counter += 1
D_local.append((msd/(counter*6*T)))
MSDX.append(msdx/(6*counter));MSDY.append(msdy/(6*counter));MSDZ.append(msdz/(6*counter));MSD.append(msd/(6*counter))
# ballistic_end = 100ps
degree = 1
start = int(round(len(MSD)/5.0))
p = np.polyfit(time[start:],MSD[start:],degree) # last 4/5 of the dataset
f = np.polyval(p,time)
d_mean_lastpart = p[0]#*10**(-8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s]
p1 = np.polyfit(time[0:start],MSD[0:start],degree)
f1 = np.polyval(p1,time)
d_mean_firstpart = p1[0]#*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s]
p2 = np.polyfit(time[0:int(round(start/2.0))],MSD[0:int(round(start/2.0))],degree)
f2 = np.polyval(p2,time)
d_mean_initpart = p2[0]#*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s]
p3 = np.polyfit(time[0:100],MSD[0:100],degree)
f3 = np.polyval(p3,time)
d_mean_actual = p3[0]#*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s]
print "#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#"
print " Nvalues in estimate 1 = 100"
print " Nvalues in estimate 2 = %g" % (int(round(start/2.0)))
print " Nvalues in estimate 3 = %g" % (int(round(start)))
print " Nvalues in estimate 4 = %g" % (len(time[start:]))
###############################################################################
# plotting
#plt.close('all')
plt.figure() # Figure 1
Title = 'Mean square displacement'
legends = ['$msd_{x}$','$msd_{y}$','$msd_{z}$','$msd$']#['$msd$']#
Ylabel = 'mean square displacement $ [A^2] $'
Xlabel = 'time $ [ps] $'
pltname = 'MSD_bulkwater'
linestyles = ['--r','--y','--k','o-b']#['--r'] #
plt.hold(True)
plt.plot(time,MSDX,linestyles[0])
plt.plot(time,MSDY,linestyles[1])
plt.plot(time,MSDZ,linestyles[2])
plt.plot(time,MSD,linestyles[3],markevery=10)
plt.title(Title)
plt.xlabel(Xlabel)
plt.ylabel(Ylabel)
plt.legend(legends,loc='lower right')
plt.hold(False)
write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[time],[MSDX,MSDY,MSDZ,MSD])
from mpl_toolkits.axes_grid.inset_locator import zoomed_inset_axes, inset_axes, mark_inset
plt.figure()
ax = plt.axes() # Figure 2
Title = 'Mean square displacement'
legends = ['MSD','$f_1 %.3f $' % (d_mean_actual),'$f_2 %.3f $' % (d_mean_initpart),'$f_3 %.3f $' % (d_mean_firstpart),'$f_4 %.3f $' % (d_mean_lastpart)]
pltname = 'MSD_bulkwater_mean'
Xlabel = 'time $ [ps] $'
Ylabel = 'mean square displacement $ [A^2] $'
linestyles = ['b-','--y','--r','--m','--y']
plt.hold(True)
plt.plot(time,MSD,linestyles[0])
plt.plot(time[0:int(round(len(f)/8.0))],f3[0:int(round(len(f)/8.0))],linestyles[1]) # very first part
plt.plot(time[0:int(round(len(f)/6.0))],f2[0:int(round(len(f)/6.0))],linestyles[2]) # initpart
plt.plot(time[0:int(round(len(f)/5.0))],f1[0:int(round(len(f)/5.0))],linestyles[3]) # firstpart
plt.plot(time,f,linestyles[4]) # lastpart
plt.hold(False)
plt.xlabel(Xlabel)
plt.ylabel(Ylabel)
plt.legend(legends,loc='lower right')
plt.title(Title)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
axin = inset_axes(ax, width="30%", height="35%", loc=8)
plt.hold(True)
axin.plot(time,MSD,linestyles[0])
axin.plot(time,f3,linestyles[1],linewidth=3.0)
axin.plot(time,f2,linestyles[2])
#axin.plot(time,f1,linestyles[3])
plt.hold(False)
axin.set_xlim(500, 520)
ya = 0.0
yb = 4.0
Npoints = 4
points = np.linspace(ya,yb,Npoints)
axin.set_ylim(ya, yb)
axin.set_xticks([])
axin.set_yticks(points)
mark_inset(ax, axin, loc1=3, loc2=4, fc="none", ec="0.5")
write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[time],[MSD,f])
print "#################################################################"
print "# Diffusion estimate f1 : D = %.10f " % (d_mean_actual)
print "# Diffusion estimate f2 : D = %.10f " % (d_mean_initpart)
print "# Diffusion estimate f3 : D = %.10f " % (d_mean_firstpart)
print "# Diffusion estimate f4 : D = %.10f " % (d_mean_lastpart)
plt.figure() # Figure 3
Title = 'Time evolution of the local diffusion constant. $ D=(msd/6dt) $'
legends = ['$D(t)$']; linestyles = ['-y']
pltname = 'Diffusion_bulkwater'
Ylabel = 'displacement $ [ %g m^2/s]$' % factor
plt.hold(True)
plt.plot(time,D_local,linestyles[0])
plt.hold(False)
plt.legend(legends,loc='upper right')
plt.title(Title)
plt.xlabel(Xlabel)
plt.ylabel(Ylabel)
write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[time],[D_local])
plt.show()
def main():
#calculation = "TraPPE" # diffusion calc for the TraPPE co2 system
#calculation = "EMP2" # diffusion calc for the EMP2 co2 system
#calculation = "FPF" # diffusion calc for the FPF co2 system
calculation = "Bulk water" # diffusion for bulk water
#calculation = "Portlandite" # diffusion for Portlandite cube
Nstatefiles = 100 # Number of statefiles to use in every estimate
timestep = 2.0 # timestep used in MD simulation. [fsec]
if (calculation == "Bulk water"):
print " Running for bulk water!!!"
'''
startingtime = 200000
pathtodatabase = '/home/goran/lammps-28Jun14/examples/Abel_runs/water/pure_H2O/Small_bulk_system' # bulk water
initialfile = 'dump.water_nvt_fromRestart.250000.txt'
frontname = "dump.water_nvt_fromRestart"
arg = "water_nvt_fromRestart"
outputfilename = 'diffusion_bulkwater_plotshit.dat'
Type = 1 # What atom type to follow
'''
startingtime = 250100
pathtodatabase = "/home/goran/lammps-28Jun14/theproject/water/run3_300K_100ps_nvt" # Bulk water
initialfile = "dump.water_nvt.250100.txt" # Filename of initial state
frontname = "dump.water_nvt"
arg = None
outputfilename = "diffusion_bulkwater_plotshit.data"
Type = 1
if (calculation == "TraPPE"):
last_timestep = 250000
startingtime = 200000
Nsteps = last_timestep - startingtime
pathtodatabase = '/home/goran/lammps-28Jun14/theproject/carbondioxide/TraPPE/run_2015_02_27' # bulk carbon dioxide, TraPPE model
initialfile = 'dump.bulk_carbondioxide_TraPPE.0.txt'
frontname = "dump.bulk_carbondioxide_TraPPE"
arg = "bulk_carbondioxide_TraPPE"
outputfilename = "diffusion_TraPPE_co2_plotshit.dat"
Type = 1 # What atom type to follow
if (calculation == "EMP2"):
last_timestep = 250000
startingtime = 200000
Nsteps = last_timestep - startingtime
pathtodatabase = '/home/goran/lammps-28Jun14/theproject/carbondioxide/emp2/run_2015_02_27' # bulk carbon dioxide, EMP2 model
initialfile = "dump.bulk_carbondioxide_EMPtwo.0.txt"
frontname = "dump.bulk_carbondioxide_EMPtwo"
arg = "bulk_carbondioxide_EMPtwo"
outputfilename = "diffusion_EMP2_co2_plotshit.dat"
Type = 1 # What atom type to follow
if (calculation == "FPF"):
last_timestep = 250000
startingtime = 200000
Nsteps = last_timestep - startingtime
pathtodatabase = '/home/goran/lammps-28Jun14/theproject/carbondioxide/FPF/run_2015_02_26' # bulk carbon dioxide, FPF model
initialfile = 'dump.bulk_carbondioxide_FPF.0.txt'
frontname = "dump.bulk_carbondioxide_FPF"
arg = "bulk_carbondioxide_FPF"
outputfilename = 'FPF_co2_diffusion_plotshit.dat'
outputfilename = "diffusion_FPF_co2_plotshit.dat"
Type = 1 # What atom type to follow
if (calculation == "Portlandite"):
pathtodatabase = '/home/goran/lammps-28Jun14/examples/Abel_runs/portlandite/oldrun'
initialfile = "dump.portlandite.250000.txt"
frontname = "dump.portlandite"
arg = "portlandite"
outputfilename = "diffusion_Portlandite_co2_plotshit.dat"
Type = 1 # What atom type to follow
initialfile = os.path.join(pathtodatabase,initialfile)
notsortedfiles, Time = gothroughfiles(pathtodatabase,arg) # the files are not well enough sorted!
t0, Natoms, system_size, matrix0, readstructure, entries, types = readfile(initialfile)
ofile = open(outputfilename,'w')
#print len(Time), Time[-1]
#print Time
#Time = Time[0:1000]
#print "system size:\n", system_size
time = []
start = 0; k = 0;
for t in Time:
if t == startingtime:
start = k
time.append(t*timestep/1000.0) # convert to pico-seconds
k += 1
#######################################################
# DENSITY
oxygen = 15.9994 # g/mol
hydrogen = 1.00794 # g/mol
carbon = 12.0107 # g/mol
calcium = 40.078 # g/mol
silicon = 28.0855 # g/mol
if ('water' in initialfile):
mass = (oxygen + 2*hydrogen)*Natoms/3.0 # g/mol (system)
Type = 1 # follow oxygen
system = 'water'
elif ('carbondioxide' in initialfile):
mass = (carbon + 2*oxygen)*Natoms/3.0 # g/mol (system)
Type = 1 # follow carbon
system = 'water'
elif ('portlandite' in initialfile):
mass = (calcium + (oxygen + hydrogen)*2)*Natoms/5.0 # g/mol (system)
system = 'portlandite'
elif ('quartz' in initialfile):
mass = (silicon + 2*oxygen)*Natoms/3.0 # g/mol (system)
system = 'alpha-quartz'
else:
print "failed to characterize system"
#==========================================================================
#=============== MSD for system, one estimate
#displacement(ofile,timestep,Natoms,matrix0,Type,Time[start:],frontname,pathtodatabase,system_size)
#==========================================================================
#=============== MSD for system, len(time)/Nstatefiles estimates
lTime = len(Time)
stop = lTime - 1
stop = start + 500
print "len(Time) = %g " % (len(Time))
if (stop > lTime):
print "Error! stop > len(Time)\n setting stop=len(Time)"
stop = lTime-1
print "start time index = %g" % start
print "stop time index = %g" % stop
GM = storefileinfo(Time,Natoms,frontname,pathtodatabase) # store fileinfo to a grand matrix
diffusion(ofile,timestep,Natoms,Nstatefiles,GM,Type,time,system_size)
#==========================================================================
#====================== Radial Distribution ===============================
#Carbon Dioxide:
#Type1 = [1,'C',216] # molID,type,Nmolec
#Type2 = [2,'O',432] # molID,type,Nmolec
# Water:
#Type1 = [1,'O',216] # molID,type,Nmolec
#Type2 = [2,'H',432] # molID,type,Nmolec
# Portlandite:
#Type1 = [1,'Ca',1344]
#Type2 = [2,'O',2688]
# Alpha-quartz:
#Type1 = [1,'O',72] # molID,type,Natoms
#Type2 = [2,'Si',36] # molID,type,Natoms
#RDF(ofile,Time[start:],Natoms,system_size,GM,Type1,Type1,pathtodatabase) # RDF type1 - type1
#RDF(ofile,Time[start:],Natoms,system_size,GM,Type2,Type2,pathtodatabase) # RDF type2 - type2
#RDF(ofile,Time[start:],Natoms,system_size,GM,Type1,Type2,pathtodatabase) # RDF type1 - type2
#==========================================================================
#======================= Bulk Density =====================================
#notsort, Time = gothroughfiles(pathtodatabase,arg)
#bulkdensity(ofile,timestep,mass,Time[start:],frontname,pathtodatabase)
print "##############################################################"
print "# Starting timestep: %g" % Time[start]
print "# Last timestep: %g" % Time[stop]
print "# Number of files: %g" % len(time)
print "# Number of files in estimates: %g" % Nstatefiles
print "# Number of estimates: %g" % (int(np.floor(len(time)/float(Nstatefiles))))
print "##############################################################"
ofile.close()
def bulkdensity(ofile,timestep,mass_of_system,Time,frontname,pathtodatabase):
'''
masses[i] contains the mass of atom in types[i].
systemSize = [xlo xhi ylo yhi zlo zhi]
GM is a grand matrix containing all atom IDs, types and positions.
The bulkdensity function calculates the density of a bulk system
at every timestep, and plots the density as a function of time
mass_of_system
'''
avogadro_aangstrom_relation = 10.0/6.022
density = []; volume = []
i = 0
for time in Time:
path = frontname + '.%r.txt' % (time)
print "# Processing file: %s " % path
filename = os.path.abspath(os.path.join(pathtodatabase,path))
t, Natoms, system_size, matrix, readstructure, entries, types = readfile(filename) # this takes time processing !!
dx = system_size[1] - system_size[0] # Aangstrom
dy = system_size[3] - system_size[2] # Aangstrom
dz = system_size[5] - system_size[4] # Aangstrom
vol = dx*dy*dz # volume of system [Aangstrom^3]
volume.append(vol)
density.append((mass_of_system/vol)*avogadro_aangstrom_relation)
i += 1
t = []
for time in Time:
t.append(time*timestep/1000.0) # converts to pico-seconds
if "carb" in frontname:
dens = 1.7966*10**(-3) # g/cm^3
benchmarkline = np.linspace(dens,dens,5) # carbon dioxide benchmarkline for density
pltname = "Density_cardondioxide"
elif "water" in frontname:
dens = 0.998 # g/cm^3
benchmarkline = np.linspace(dens,dens,5) # water benchmarkline for density
pltname = "Density_water"
elif "quartz" in frontname:
dens = 2.648 # g/cm^3
benchmarkline = np.linspace(dens,dens,5)
pltname = "Density_quartz"
elif "portlandite" in frontname:
dens = 2.24 # g/cm^3
benchmarkline = np.linspace(dens,dens,5)
pltname = "Density_portlandite"
else:
print "ERRORERRORERRORERRORERRORERRORERRORERRORERRORERRORERRORERRORERROR"
print "Error!\n Could not recognize either 'carb', 'water', 'quartz or 'portlandite' in frontname"
start = int(round(0.1*len(density)))
meanDens = np.mean(density[start:]); stdDens = np.std(density[start:])
line = np.linspace(meanDens,meanDens,6)
Title = 'Density profile\\newline$\\rho = %.4g \\pm %.5g [g/cm^3]$' % (meanDens,stdDens)
Xlabel = 'time $ [ps] $'; Ylabel = 'density $ [g/cm^3] $'
legends = ['$\\rho$','$\\rho_{avg}$','$\\rho_{exp}$']; linestyles = ['g--','b-d','r-o']
tstop = t[-1]
tstart = t[0]
dt = tstop - tstart
line_points = [tstart,(tstart + dt/5), (tstart + 2*dt/5), (tstart + 3*dt/5), (tstart + 4*dt/5), tstop]
benchmarkline_points = [tstart,(tstart + dt/4), (tstart + dt/2), (tstart + 3*dt/4), tstop]
plt.figure()
plt.hold(True)
plt.plot(t,density,'g--')
plt.plot(line_points,line,'b-d', linewidth=3.0)
plt.plot(benchmarkline_points,benchmarkline,'r-o',linewidth=2.0)
plt.hold(False)
plt.title(Title)
plt.legend(legends)
plt.xlabel(Xlabel); plt.ylabel(Ylabel)
meanVol = np.mean(volume); stdVol = np.std(volume)
Title = '$V_{system} = %g \\pm %g A^3$' % (meanVol,stdVol)
Xlabel = 'time [ps]'; Ylabel = 'volume'
plt.figure()
plt.plot(t,volume,'-b')
plt.title(Title); plt.xlabel(Xlabel);plt.ylabel(Ylabel)
plt.legend(['volume'],loc='upper left')
plt.show()
write_to_file(ofile,Title,Xlabel,Ylabel,pltname,legends,linestyles,[t,line_points,benchmarkline_points],[density,line,benchmarkline])
def main():
#calculation = "TraPPE" # diffusion calc for the TraPPE co2 system
#calculation = "EMP2" # diffusion calc for the EMP2 co2 system
#calculation = "FPF" # diffusion calc for the FPF co2 system
calculation = "Bulk water" # diffusion for bulk water
#calculation = "Portlandite" # diffusion for Portlandite cube
Nstatefiles = 100 # Number of statefiles to use in every estimate
timestep = 2.0 # timestep used in MD simulation. [fsec]
if (calculation == "Bulk water"):
print " Running for bulk water!!!"
'''
startingtime = 200000
pathtodatabase = '/home/goran/lammps-28Jun14/examples/Abel_runs/water/pure_H2O/Small_bulk_system' # bulk water
initialfile = 'dump.water_nvt_fromRestart.250000.txt'
frontname = "dump.water_nvt_fromRestart"
arg = "water_nvt_fromRestart"
outputfilename = 'diffusion_bulkwater_plotshit.dat'
Type = 1 # What atom type to follow
'''
startingtime = 250100
pathtodatabase = "/home/goran/lammps-28Jun14/theproject/water/run3_300K_100ps_nvt" # Bulk water
initialfile = "dump.water_nvt.250100.txt" # Filename of initial state
frontname = "dump.water_nvt"
arg = None
outputfilename = "diffusion_bulkwater_plotshit.data"
Type = 1
if (calculation == "TraPPE"):
last_timestep = 250000
startingtime = 200000
Nsteps = last_timestep - startingtime
pathtodatabase = '/home/goran/lammps-28Jun14/theproject/carbondioxide/TraPPE/run_2015_02_27' # bulk carbon dioxide, TraPPE model
initialfile = 'dump.bulk_carbondioxide_TraPPE.0.txt'
frontname = "dump.bulk_carbondioxide_TraPPE"
arg = "bulk_carbondioxide_TraPPE"
outputfilename = "diffusion_TraPPE_co2_plotshit.dat"
Type = 1 # What atom type to follow
if (calculation == "EMP2"):
last_timestep = 250000
startingtime = 200000
Nsteps = last_timestep - startingtime
pathtodatabase = '/home/goran/lammps-28Jun14/theproject/carbondioxide/emp2/run_2015_02_27' # bulk carbon dioxide, EMP2 model
initialfile = "dump.bulk_carbondioxide_EMPtwo.0.txt"
frontname = "dump.bulk_carbondioxide_EMPtwo"
arg = "bulk_carbondioxide_EMPtwo"
outputfilename = "diffusion_EMP2_co2_plotshit.dat"
Type = 1 # What atom type to follow
if (calculation == "FPF"):
last_timestep = 250000
startingtime = 200000
Nsteps = last_timestep - startingtime
pathtodatabase = '/home/goran/lammps-28Jun14/theproject/carbondioxide/FPF/run_2015_02_26' # bulk carbon dioxide, FPF model
initialfile = 'dump.bulk_carbondioxide_FPF.0.txt'
frontname = "dump.bulk_carbondioxide_FPF"
arg = "bulk_carbondioxide_FPF"
outputfilename = 'FPF_co2_diffusion_plotshit.dat'
outputfilename = "diffusion_FPF_co2_plotshit.dat"
Type = 1 # What atom type to follow
if (calculation == "Portlandite"):
pathtodatabase = '/home/goran/lammps-28Jun14/examples/Abel_runs/portlandite/oldrun'
initialfile = "dump.portlandite.250000.txt"
frontname = "dump.portlandite"
arg = "portlandite"
outputfilename = "diffusion_Portlandite_co2_plotshit.dat"
Type = 1 # What atom type to follow
initialfile = os.path.join(pathtodatabase, initialfile)
notsortedfiles, Time = gothroughfiles(
pathtodatabase, arg) # the files are not well enough sorted!
t0, Natoms, system_size, matrix0, readstructure, entries, types = readfile(
initialfile)
ofile = open(outputfilename, 'w')
#print len(Time), Time[-1]
#print Time
#Time = Time[0:1000]
#print "system size:\n", system_size
time = []
start = 0
k = 0
for t in Time:
if t == startingtime:
start = k
time.append(t * timestep / 1000.0) # convert to pico-seconds
k += 1
#######################################################
# DENSITY
oxygen = 15.9994 # g/mol
hydrogen = 1.00794 # g/mol
carbon = 12.0107 # g/mol
calcium = 40.078 # g/mol
silicon = 28.0855 # g/mol
if ('water' in initialfile):
mass = (oxygen + 2 * hydrogen) * Natoms / 3.0 # g/mol (system)
Type = 1 # follow oxygen
system = 'water'
elif ('carbondioxide' in initialfile):
mass = (carbon + 2 * oxygen) * Natoms / 3.0 # g/mol (system)
Type = 1 # follow carbon
system = 'water'
elif ('portlandite' in initialfile):
mass = (calcium +
(oxygen + hydrogen) * 2) * Natoms / 5.0 # g/mol (system)
system = 'portlandite'
elif ('quartz' in initialfile):
mass = (silicon + 2 * oxygen) * Natoms / 3.0 # g/mol (system)
system = 'alpha-quartz'
else:
print "failed to characterize system"
#==========================================================================
#=============== MSD for system, one estimate
#displacement(ofile,timestep,Natoms,matrix0,Type,Time[start:],frontname,pathtodatabase,system_size)
#==========================================================================
#=============== MSD for system, len(time)/Nstatefiles estimates
lTime = len(Time)
stop = lTime - 1
stop = start + 500
print "len(Time) = %g " % (len(Time))
if (stop > lTime):
print "Error! stop > len(Time)\n setting stop=len(Time)"
stop = lTime - 1
print "start time index = %g" % start
print "stop time index = %g" % stop
GM = storefileinfo(Time, Natoms, frontname,
pathtodatabase) # store fileinfo to a grand matrix
diffusion(ofile, timestep, Natoms, Nstatefiles, GM, Type, time,
system_size)
#==========================================================================
#====================== Radial Distribution ===============================
#Carbon Dioxide:
#Type1 = [1,'C',216] # molID,type,Nmolec
#Type2 = [2,'O',432] # molID,type,Nmolec
# Water:
#Type1 = [1,'O',216] # molID,type,Nmolec
#Type2 = [2,'H',432] # molID,type,Nmolec
# Portlandite:
#Type1 = [1,'Ca',1344]
#Type2 = [2,'O',2688]
# Alpha-quartz:
#Type1 = [1,'O',72] # molID,type,Natoms
#Type2 = [2,'Si',36] # molID,type,Natoms
#RDF(ofile,Time[start:],Natoms,system_size,GM,Type1,Type1,pathtodatabase) # RDF type1 - type1
#RDF(ofile,Time[start:],Natoms,system_size,GM,Type2,Type2,pathtodatabase) # RDF type2 - type2
#RDF(ofile,Time[start:],Natoms,system_size,GM,Type1,Type2,pathtodatabase) # RDF type1 - type2
#==========================================================================
#======================= Bulk Density =====================================
#notsort, Time = gothroughfiles(pathtodatabase,arg)
#bulkdensity(ofile,timestep,mass,Time[start:],frontname,pathtodatabase)
print "##############################################################"
print "# Starting timestep: %g" % Time[start]
print "# Last timestep: %g" % Time[stop]
print "# Number of files: %g" % len(time)
print "# Number of files in estimates: %g" % Nstatefiles
print "# Number of estimates: %g" % (int(
np.floor(len(time) / float(Nstatefiles))))
print "##############################################################"
ofile.close()
def displacement(ofile, timestep, Natoms, matrix0, Type, Time, frontname,
pathtodatabase, systemsize):
'''
timestep,system_size,matrix0 contain the initial information about the system.
we have to go through sortedfiles to find information about the particles at
later timesteps.
'''
factor = 10**(-8) # conversionfactor from [A^2/ps] -> [m^2/s]
Lx = systemsize[1] - systemsize[0]
Ly = systemsize[3] - systemsize[2]
Lz = systemsize[5] - systemsize[4]
halfsystemsize = 0.5 * (Lx + Ly + Lz) / 3.0 # half of average system size
time = []
for t in Time:
time.append(timestep * t / 1000.0) # to picoseconds
#time.append(t)
MSDX = []
MSDY = []
MSDZ = []
MSD = []
D_local = []
dt = (time[1] - time[0])
for T in Time:
path = frontname + '.%r.txt' % (T)
print path
msdx = 0
msdy = 0
msdz = 0
msd = 0
filename = os.path.abspath(os.path.join(pathtodatabase, path))
t, Natoms, system_size, matrix, readstructure, entries, types = readfile(
filename)
counter = 0
for i in range(Natoms):
if (matrix['type'][i] == Type):
ID = matrix['id'][i]
initial_index = None
for j in range(Natoms):
k = matrix0['id'][j]
if (k == ID):
initial_index = j
break
dx = matrix['x'][i] - matrix0['x'][initial_index]
dy = matrix['y'][i] - matrix0['y'][initial_index]
dz = matrix['z'][i] - matrix0['z'][initial_index]
msdx += (dx)**2
msdy += (dy)**2
msdz += (dz)**2
########################################
# MINIMUM IMAGE CONVENTION #
if (dx < -halfsystemsize): dx = dx + Lx
if (dx > halfsystemsize): dx = dx - Lx
if (dy < -halfsystemsize): dy = dy + Ly
if (dy > halfsystemsize): dy = dy - Ly
if (dz < -halfsystemsize): dz = dz + Lz
if (dz > halfsystemsize): dz = dz - Lz
########################################
msd += dx**2 + dy**2 + dz**2
counter += 1
D_local.append((msd / (counter * 6 * T)))
MSDX.append(msdx / (6 * counter))
MSDY.append(msdy / (6 * counter))
MSDZ.append(msdz / (6 * counter))
MSD.append(msd / (6 * counter))
# ballistic_end = 100ps
degree = 1
start = int(round(len(MSD) / 5.0))
p = np.polyfit(time[start:], MSD[start:],
degree) # last 4/5 of the dataset
f = np.polyval(p, time)
d_mean_lastpart = p[
0] #*10**(-8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s]
p1 = np.polyfit(time[0:start], MSD[0:start], degree)
f1 = np.polyval(p1, time)
d_mean_firstpart = p1[
0] #*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s]
p2 = np.polyfit(time[0:int(round(start / 2.0))],
MSD[0:int(round(start / 2.0))], degree)
f2 = np.polyval(p2, time)
d_mean_initpart = p2[
0] #*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s]
p3 = np.polyfit(time[0:100], MSD[0:100], degree)
f3 = np.polyval(p3, time)
d_mean_actual = p3[
0] #*10**(8) # to get [m^2/s]. [A^2/ps] = 10**(-8)[m^2/s]
print "#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#"
print " Nvalues in estimate 1 = 100"
print " Nvalues in estimate 2 = %g" % (int(round(start / 2.0)))
print " Nvalues in estimate 3 = %g" % (int(round(start)))
print " Nvalues in estimate 4 = %g" % (len(time[start:]))
###############################################################################
# plotting
#plt.close('all')
plt.figure() # Figure 1
Title = 'Mean square displacement'
legends = ['$msd_{x}$', '$msd_{y}$', '$msd_{z}$', '$msd$'] #['$msd$']#
Ylabel = 'mean square displacement $ [A^2] $'
Xlabel = 'time $ [ps] $'
pltname = 'MSD_bulkwater'
linestyles = ['--r', '--y', '--k', 'o-b'] #['--r'] #
plt.hold(True)
plt.plot(time, MSDX, linestyles[0])
plt.plot(time, MSDY, linestyles[1])
plt.plot(time, MSDZ, linestyles[2])
plt.plot(time, MSD, linestyles[3], markevery=10)
plt.title(Title)
plt.xlabel(Xlabel)
plt.ylabel(Ylabel)
plt.legend(legends, loc='lower right')
plt.hold(False)
write_to_file(ofile, Title, Xlabel, Ylabel, pltname, legends, linestyles,
[time], [MSDX, MSDY, MSDZ, MSD])
from mpl_toolkits.axes_grid.inset_locator import zoomed_inset_axes, inset_axes, mark_inset
plt.figure()
ax = plt.axes() # Figure 2
Title = 'Mean square displacement'
legends = [
'MSD',
'$f_1 %.3f $' % (d_mean_actual),
'$f_2 %.3f $' % (d_mean_initpart),
'$f_3 %.3f $' % (d_mean_firstpart),
'$f_4 %.3f $' % (d_mean_lastpart)
]
pltname = 'MSD_bulkwater_mean'
Xlabel = 'time $ [ps] $'
Ylabel = 'mean square displacement $ [A^2] $'
linestyles = ['b-', '--y', '--r', '--m', '--y']
plt.hold(True)
plt.plot(time, MSD, linestyles[0])
plt.plot(time[0:int(round(len(f) / 8.0))], f3[0:int(round(len(f) / 8.0))],
linestyles[1]) # very first part
plt.plot(time[0:int(round(len(f) / 6.0))], f2[0:int(round(len(f) / 6.0))],
linestyles[2]) # initpart
plt.plot(time[0:int(round(len(f) / 5.0))], f1[0:int(round(len(f) / 5.0))],
linestyles[3]) # firstpart
plt.plot(time, f, linestyles[4]) # lastpart
plt.hold(False)
plt.xlabel(Xlabel)
plt.ylabel(Ylabel)
plt.legend(legends, loc='lower right')
plt.title(Title)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
axin = inset_axes(ax, width="30%", height="35%", loc=8)
plt.hold(True)
axin.plot(time, MSD, linestyles[0])
axin.plot(time, f3, linestyles[1], linewidth=3.0)
axin.plot(time, f2, linestyles[2])
#axin.plot(time,f1,linestyles[3])
plt.hold(False)
axin.set_xlim(500, 520)
ya = 0.0
yb = 4.0
Npoints = 4
points = np.linspace(ya, yb, Npoints)
axin.set_ylim(ya, yb)
axin.set_xticks([])
axin.set_yticks(points)
mark_inset(ax, axin, loc1=3, loc2=4, fc="none", ec="0.5")
write_to_file(ofile, Title, Xlabel, Ylabel, pltname, legends, linestyles,
[time], [MSD, f])
print "#################################################################"
print "# Diffusion estimate f1 : D = %.10f " % (d_mean_actual)
print "# Diffusion estimate f2 : D = %.10f " % (d_mean_initpart)
print "# Diffusion estimate f3 : D = %.10f " % (d_mean_firstpart)
print "# Diffusion estimate f4 : D = %.10f " % (d_mean_lastpart)
plt.figure() # Figure 3
Title = 'Time evolution of the local diffusion constant. $ D=(msd/6dt) $'
legends = ['$D(t)$']
linestyles = ['-y']
pltname = 'Diffusion_bulkwater'
Ylabel = 'displacement $ [ %g m^2/s]$' % factor
plt.hold(True)
plt.plot(time, D_local, linestyles[0])
plt.hold(False)
plt.legend(legends, loc='upper right')
plt.title(Title)
plt.xlabel(Xlabel)
plt.ylabel(Ylabel)
write_to_file(ofile, Title, Xlabel, Ylabel, pltname, legends, linestyles,
[time], [D_local])
plt.show()
def bulkdensity(ofile, timestep, mass_of_system, Time, frontname,
pathtodatabase):
'''
masses[i] contains the mass of atom in types[i].
systemSize = [xlo xhi ylo yhi zlo zhi]
GM is a grand matrix containing all atom IDs, types and positions.
The bulkdensity function calculates the density of a bulk system
at every timestep, and plots the density as a function of time
mass_of_system
'''
avogadro_aangstrom_relation = 10.0 / 6.022
density = []
volume = []
i = 0
for time in Time:
path = frontname + '.%r.txt' % (time)
print "# Processing file: %s " % path
filename = os.path.abspath(os.path.join(pathtodatabase, path))
t, Natoms, system_size, matrix, readstructure, entries, types = readfile(
filename) # this takes time processing !!
dx = system_size[1] - system_size[0] # Aangstrom
dy = system_size[3] - system_size[2] # Aangstrom
dz = system_size[5] - system_size[4] # Aangstrom
vol = dx * dy * dz # volume of system [Aangstrom^3]
volume.append(vol)
density.append((mass_of_system / vol) * avogadro_aangstrom_relation)
i += 1
t = []
for time in Time:
t.append(time * timestep / 1000.0) # converts to pico-seconds
if "carb" in frontname:
dens = 1.7966 * 10**(-3) # g/cm^3
benchmarkline = np.linspace(
dens, dens, 5) # carbon dioxide benchmarkline for density
pltname = "Density_cardondioxide"
elif "water" in frontname:
dens = 0.998 # g/cm^3
benchmarkline = np.linspace(dens, dens,
5) # water benchmarkline for density
pltname = "Density_water"
elif "quartz" in frontname:
dens = 2.648 # g/cm^3
benchmarkline = np.linspace(dens, dens, 5)
pltname = "Density_quartz"
elif "portlandite" in frontname:
dens = 2.24 # g/cm^3
benchmarkline = np.linspace(dens, dens, 5)
pltname = "Density_portlandite"
else:
print "ERRORERRORERRORERRORERRORERRORERRORERRORERRORERRORERRORERRORERROR"
print "Error!\n Could not recognize either 'carb', 'water', 'quartz or 'portlandite' in frontname"
start = int(round(0.1 * len(density)))
meanDens = np.mean(density[start:])
stdDens = np.std(density[start:])
line = np.linspace(meanDens, meanDens, 6)
Title = 'Density profile\\newline$\\rho = %.4g \\pm %.5g [g/cm^3]$' % (
meanDens, stdDens)
Xlabel = 'time $ [ps] $'
Ylabel = 'density $ [g/cm^3] $'
legends = ['$\\rho$', '$\\rho_{avg}$', '$\\rho_{exp}$']
linestyles = ['g--', 'b-d', 'r-o']
tstop = t[-1]
tstart = t[0]
dt = tstop - tstart
line_points = [
tstart, (tstart + dt / 5), (tstart + 2 * dt / 5),
(tstart + 3 * dt / 5), (tstart + 4 * dt / 5), tstop
]
benchmarkline_points = [
tstart, (tstart + dt / 4), (tstart + dt / 2), (tstart + 3 * dt / 4),
tstop
]
plt.figure()
plt.hold(True)
plt.plot(t, density, 'g--')
plt.plot(line_points, line, 'b-d', linewidth=3.0)
plt.plot(benchmarkline_points, benchmarkline, 'r-o', linewidth=2.0)
plt.hold(False)
plt.title(Title)
plt.legend(legends)
plt.xlabel(Xlabel)
plt.ylabel(Ylabel)
meanVol = np.mean(volume)
stdVol = np.std(volume)
Title = '$V_{system} = %g \\pm %g A^3$' % (meanVol, stdVol)
Xlabel = 'time [ps]'
Ylabel = 'volume'
plt.figure()
plt.plot(t, volume, '-b')
plt.title(Title)
plt.xlabel(Xlabel)
plt.ylabel(Ylabel)
plt.legend(['volume'], loc='upper left')
plt.show()
write_to_file(ofile, Title, Xlabel, Ylabel, pltname, legends, linestyles,
[t, line_points, benchmarkline_points],
[density, line, benchmarkline])