def showZMat(self,s,sel):
view=self.treeview
s=Structure(s)
s.setCarthesian()
view.set_model(ZMatTreeModel(s,sel))
for x in self.treeview.get_columns():
view.remove_column(x)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("#", renderer, markup=0)
view.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("distance", renderer, markup=1)
view.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("angle", renderer, markup=2)
view.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("dihedral", renderer, markup=3)
view.append_column(column)
view.show()
def showDistances(self,s,sel):
view=self.treeview
s=Structure(s)
s.setCarthesian()
view.set_model(DistanceTreeModel(s,sel))
for x in self.treeview.get_columns():
view.remove_column(x)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("#", renderer, markup=0)
view.append_column(column)
renderer = gtk.CellRendererText()
for i in range(len(sel)):
n,nx,ny,nz=sel[i]
column = gtk.TreeViewColumn("%d (%d %d %d)"%(n+1,nx,ny,nz), renderer, markup=i+1)
view.append_column(column)
view.show()
def updateCreation(self):
s = getCurrentSystemPM()
self.creation = SetupPM(s)
name = self.nameentry.get_text()
self.creation.INCAR["SYSTEM"] = name
if self.import_button.get_active():
self.creation = SetupPM(s)
name = self.nameentry.get_text()
self.creation.INCAR["SYSTEM"] = name
self.updateImportDescription()
# print "updateCreation",self.creation.NAME
se = strip(self.step_entry.get_text())
buff = self.description_textview.get_buffer()
start = buff.get_start_iter()
end = buff.get_end_iter()
self.creation.DESCRIPTION = str(buff.get_text(start, end))
try:
n = int(se)
try:
struct = s.STRUCTURE_SEQUENCE_L[n]
if n is not None:
self.creation.INITIAL_STRUCTURE.setStructure(struct)
except:
msg().exception()
self.creation.INITIAL_STRUCTURE = Structure()
except:
if len(se):
if upper(se[0]) == "I":
if s.INITIAL_STRUCTURE is not None:
self.creation.INITIAL_STRUCTURE.setStructure(
s.INITIAL_STRUCTURE)
else:
self.creation.INITIAL_STRUCTURE = Structure()
elif upper(se[0]) == "F":
if s.FINAL_STRUCTURE is not None:
self.creation.INITIAL_STRUCTURE.setStructure(
s.FINAL_STRUCTURE)
else:
self.creation.INITIAL_STRUCTURE = Structure()
else:
self.creation = SetupPM()
name = self.nameentry.get_text()
self.creation.INCAR["SYSTEM"] = name
def textview2struct(self):
# print "before tv2s",len(self.getCurrentStructure())
try:
b = self.textview.get_buffer()
t = b.get_text(b.get_start_iter(), b.get_end_iter(), True)
s = Structure()
s.parse(t)
self.getCurrentStructure().setStructure(s)
self.no_coord_upd = 1
if s.isCarthesian():
self.carthesian_button.set_active(True)
else:
self.direct_button.set_active(True)
# systemlist().notifySystemChanged()
except ParseException:
msg().error(str(sys.exc_info()[1]))
except:
msg().exception()
else:
msg().status("OK")
self.no_coord_upd = 0
def makeZigzag(nn,aCC=1.419398,r=None,x_shift=0.0,y_shift=0.0,z_shift=0.0):
s=Structure()
s.setCartesian()
s.comment="zigzag (%d,0), aCC=%f"%(nn,aCC)
shift = 0.0
fi = 2*pi/nn
if r is None:
r = aCC*sqrt(3.0)/4/sin(fi/4)
for i in range(0,nn):
ffi=fi*i
s.appendAtom(0,Vector(x_shift+r*cos(ffi),y_shift+r*sin(ffi),z_shift+shift))
shift = shift + aCC/2
for i in range(0,nn):
ffi=fi*(i+0.5)
s.appendAtom(0,Vector(x_shift+r*cos(ffi),y_shift+r*sin(ffi),z_shift+shift))
shift = shift + aCC
for i in range(0,nn):
ffi=fi*(i+0.5)
s.appendAtom(0,Vector(x_shift+r*cos(ffi),y_shift+r*sin(ffi),z_shift+shift))
shift = shift + aCC/2
for i in range(0,nn):
ffi=fi*(i)
s.appendAtom(0,Vector(x_shift+r*cos(ffi),y_shift+r*sin(ffi),z_shift+shift))
s.basis[0][0] = 2*r+7
s.basis[1][1] = 2*r+7
s.basis[2][2] = shift
s.R = r
return s
def makeZigzag(nn,
aCC=1.419398,
r=None,
x_shift=0.0,
y_shift=0.0,
z_shift=0.0):
s = Structure()
s.setCartesian()
s.comment = "zigzag (%d,0), aCC=%f" % (nn, aCC)
shift = 0.0
fi = 2 * pi / nn
if r is None:
r = aCC * sqrt(3.0) / 4 / sin(fi / 4)
for i in range(0, nn):
ffi = fi * i
s.appendAtom(
0,
Vector(x_shift + r * cos(ffi), y_shift + r * sin(ffi),
z_shift + shift))
shift = shift + aCC / 2
for i in range(0, nn):
ffi = fi * (i + 0.5)
s.appendAtom(
0,
Vector(x_shift + r * cos(ffi), y_shift + r * sin(ffi),
z_shift + shift))
shift = shift + aCC
for i in range(0, nn):
ffi = fi * (i + 0.5)
s.appendAtom(
0,
Vector(x_shift + r * cos(ffi), y_shift + r * sin(ffi),
z_shift + shift))
shift = shift + aCC / 2
for i in range(0, nn):
ffi = fi * (i)
s.appendAtom(
0,
Vector(x_shift + r * cos(ffi), y_shift + r * sin(ffi),
z_shift + shift))
s.basis[0][0] = 2 * r + 7
s.basis[1][1] = 2 * r + 7
s.basis[2][2] = shift
s.R = r
return s
######################################################################
# This is a selection script example. #
# The purpose of this script is to select (in the sense of the #
# "Selective dynamics") certain atom group. #
# #
# It is very simple and it is easier to modify this source #
# to do what you want, than to write a sophisticated user interface. #
# (see the comments) #
######################################################################
from p4vasp.Structure import *
from p4vasp.sellang import *
from p4vasp.SystemPM import *
# Read the structure.
p=Structure("POSCAR")
# Alternative:
#p=XMLSystemPM("vasprun.xml").FINAL_STRUCTURE
l=decode("#4",p) # Select the 4th specie
p.setSelective() # Selective mode.
for i in range(len(p)):
if i in l:
p.selective[i]=(1,1,1)
else:
p.selective[i]=(0,0,0)
p.write("POSCAR.selected") # Write the output.
#!/usr/bin/env python
import os
import time
import sys
import re
from p4vasp.Structure import *
if len(sys.argv) < 2:
print "Usage: "+sys.argv[0]+" <poscar file>"
print " outputs the direct coords to stdout"
sys.exit(1)
space = re.compile(r'\s+')
file = sys.argv[1]
p=Structure(file)
p.setDirect()
p.write(sys.stdout)
# (see http://cms.mpi.univie.ac.at/vasp/Welcome.html)
#
# Copyright (C) 2003 Orest Dubay <*****@*****.**>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from p4vasp.Structure import *
from sys import *
s=Structure("POSCAR")
s.setSelective(0)
nx=int(argv[1])
ny=int(argv[2])
nz=int(argv[3])
s.replicateCell(nx,ny,nz)
s.write("POSCAR_%d-%d-%d"%(nx,ny,nz))
######################################################################
# This is a selection script example. #
# The purpose of this script is to select (in the sense of the #
# "Selective dynamics") certain atom group. #
# #
# It is very simple and it is easier to modify this source #
# to do what you want, than to write a sophisticated user interface. #
# (see the comments) #
######################################################################
from p4vasp.Structure import *
from p4vasp.sellang import *
from p4vasp.SystemPM import *
# Read the structure.
p=Structure("POSCAR")
# Alternative:
#p=XMLSystemPM("vasprun.xml").FINAL_STRUCTURE
l=decode("#4",p) # Select the 4th specie
p.setSelective() # Selective mode.
for i in range(len(p)):
if i in l:
p.selective[i]=(1,1,1)
else:
p.selective[i]=(0,0,0)
p.write("POSCAR.selected") # Write the output.
#!/usr/bin/env python
import os
import time
import sys
import re
from p4vasp.Structure import *
if len(sys.argv) < 2:
print "Usage: "+sys.argv[0]+" <poscar file>"
print " outputs the cartesian coords to stdout"
sys.exit(1)
space = re.compile(r'\s+')
file = sys.argv[1]
p=Structure(file)
p.setCarthesian()
p.write(sys.stdout)
# Vienna Ab-inition Simulation Package (VASP)
# (see http://cms.mpi.univie.ac.at/vasp/Welcome.html)
#
# Copyright (C) 2003 Orest Dubay <*****@*****.**>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from p4vasp.Structure import *
from sys import *
s=Structure("POSCAR")
s.setCarthesian()
for i in range(len(s)):
s[i][1]*=-1
s.toUnitCell()
s.write("POSCAR.Y-mirror")
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
######################################################################
# DESCRIPTION: #
######################################################################
# This is a removes all but selected atoms. #
# Selection is given by selection language at the #
# line with decode("..."). #
# #
# It is very simple and it is easier to modify this source #
# to do what you want, than to write a sophisticated user interface. #
# (see the comments) #
######################################################################
from p4vasp.Structure import *
from p4vasp.sellang import *
from p4vasp.SystemPM import *
# Read the structure.
p=Structure("POSCAR")
# Alternative:
#p=XMLSystemPM("vasprun.xml").FINAL_STRUCTURE
#del p[59]
#Now remove specie 2
p.remove("#2")
#Finally write the output.
p.write("POSCAR.removed") # Write the output.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
######################################################################
# DESCRIPTION: #
######################################################################
# Removes the selective dynamics from the inputfile #
######################################################################
from p4vasp.Structure import *
from p4vasp.sellang import *
from p4vasp.SystemPM import *
from sys import *
# Read the structure.
p=Structure(argv[1])
p.setSelective(0) # Selective mode.
p.write("%s.notselective"%argv[1]) # Write the output.
def clone(self):
return Structure(pointer=_cp4vasp.Structure_clone(self.this))
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from p4vasp.Structure import *
from p4vasp.sellang import *
#from p4vasp.SystemPM import *
#s=XMLSystemPM('vasprun.xml')
#p=s.INITIAL_STRUCTURE
p=Structure("CONTCAR")
p.setCarthesian()
l1=decode("-160",p)
l2=decode("161-",p)
print "Group 1 has %3d elements."%len(l1)
print "Group 2 has %3d elements."%len(l2)
d=[]
for i in l1:
for j in l2:
if i==j:
print "Substructures have a common atom %d."%(i+1)
else:
d.append((p.mindistCartVectors(p[i],p[j]),i,j))
m,i,j=min(d)
#!/usr/bin/python
from p4vasp.Structure import *
from sys import argv
p = Structure(argv[1])
#p.setSelective(0)
for i in range(p.types):
f = p.info.firstAtomIndexForSpecie(i)
l = []
if p.isSelective():
for j in range(p.atomspertype[i]):
l.append((p[j][2], p[j], p.selective[j]))
l.sort()
for j in range(p.atomspertype[i]):
p[j] = l[j][1]
p.selective[j] = l[j][2]
else:
for j in range(p.atomspertype[i]):
l.append((p[j][2], p[j]))
l.sort()
for j in range(p.atomspertype[i]):
p[j] = l[j][1]
p.write(argv[1] + ".sorted")
def __init__(self, a):
'''constructor for the model.'''
gtk.GenericTreeModel.__init__(self)
self.a = a
self.struct = Structure()
#!/usr/bin/python2
# p4vasp is a GUI-program and a library for processing outputs of the
# Vienna Ab-inition Simulation Package (VASP)
# (see http://cms.mpi.univie.ac.at/vasp/Welcome.html)
#
# Copyright (C) 2003 Orest Dubay <*****@*****.**>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from p4vasp.Structure import *
from sys import *
s = Structure("POSCAR")
s.setCarthesian()
for i in range(len(s)):
s[i][1] *= -1
s.toUnitCell()
s.write("POSCAR.Y-mirror")
# p4vasp is a GUI-program and a library for processing outputs of the
# Vienna Ab-inition Simulation Package (VASP)
# (see http://cms.mpi.univie.ac.at/vasp/Welcome.html)
#
# Copyright (C) 2003 Orest Dubay <*****@*****.**>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
from p4vasp.Structure import *
from sys import *
s = Structure("POSCAR")
s.setSelective(0)
nx = int(argv[1])
ny = int(argv[2])
nz = int(argv[3])
s.replicateCell(nx, ny, nz)
s.write("POSCAR_%d-%d-%d" % (nx, ny, nz))
import sys
import re
from p4vasp.Structure import *
if len(sys.argv) < 7:
print "Usage: "+sys.argv[0]+" <poscar file> <n> <m> <x> <y> <z>"
print " <poscar file> is the input POSCAR"
print " <n> <m> species the range of atoms to move (by index)"
print " <x> <y> <z> is the translation vector to add to those atoms (cartesian)."
print " The new POSCAR is output to stdout."
sys.exit(1)
space = re.compile(r'\s+')
file = sys.argv[1]
p=Structure(file)
p.setCarthesian()
n = int(sys.argv[2])
m = int(sys.argv[3])
x = float(sys.argv[4])
y = float(sys.argv[5])
z = float(sys.argv[6])
# do the move
p.translate(Vector(x,y,z),range(n,m))
# convert back to direct
p.setDirect()
# write it out.
def makeArmchair(nn,
aCC=1.419398,
r=None,
x_shift=0.0,
y_shift=0.0,
z_shift=0.0):
s = Structure()
s.setCartesian()
s.comment = "armchair (%d,%d), aCC=%f" % (nn, nn, aCC)
shift = 0.0
fi = 2 * pi / nn
al = 2 * atan(2 * sin(fi / 4) / (1 + 2 * cos(fi / 4)))
be = fi / 2 - al
if r is None:
r = aCC / 2 / sin(al / 2)
for i in range(0, nn):
ffi = fi * i
s.appendAtom(
0,
Vector(x_shift + r * cos(ffi), y_shift + r * sin(ffi),
z_shift + shift))
for i in range(0, nn):
ffi = al + fi * i
s.appendAtom(
0,
Vector(x_shift + r * cos(ffi), y_shift + r * sin(ffi),
z_shift + shift))
shift = shift + aCC * sqrt(3.0) / 2
for i in range(0, nn):
ffi = al + be + fi * (i)
s.appendAtom(
0,
Vector(x_shift + r * cos(ffi), y_shift + r * sin(ffi),
z_shift + shift))
for i in range(0, nn):
ffi = 2 * al + be + fi * (i)
s.appendAtom(
0,
Vector(x_shift + r * cos(ffi), y_shift + r * sin(ffi),
z_shift + shift))
shift = shift + aCC * sqrt(3.0) / 2
s.basis[0][0] = 2 * r + 7
s.basis[1][1] = 2 * r + 7
s.basis[2][2] = shift
s.R = r
return s
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
######################################################################
# DESCRIPTION: #
######################################################################
# This is a removes all but selected atoms. #
# Selection is given by selection language at the #
# line with decode("..."). #
# #
# It is very simple and it is easier to modify this source #
# to do what you want, than to write a sophisticated user interface. #
# (see the comments) #
######################################################################
from p4vasp.Structure import *
from p4vasp.sellang import *
from p4vasp.SystemPM import *
# Read the structure.
p=Structure("POSCAR")
# Alternative:
#p=XMLSystemPM("vasprun.xml").FINAL_STRUCTURE
#del p[59]
#Now remove specie 2
p.remove("#2")
#Finally write the output.
p.write("POSCAR.removed") # Write the output.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
######################################################################
# DESCRIPTION: #
######################################################################
# Removes the selective dynamics from the inputfile #
######################################################################
from p4vasp.Structure import *
from p4vasp.sellang import *
from p4vasp.SystemPM import *
from sys import *
# Read the structure.
p=Structure(argv[1])
p.setSelective(0) # Selective mode.
p.write("%s.notselective"%argv[1]) # Write the output.
def makeArmchair(nn,aCC=1.419398,r=None,x_shift=0.0,y_shift=0.0,z_shift=0.0):
s=Structure()
s.setCartesian()
s.comment="armchair (%d,%d), aCC=%f"%(nn,nn,aCC)
shift = 0.0
fi = 2*pi/nn
al = 2*atan(2*sin(fi/4)/(1+2*cos(fi/4)))
be = fi/2-al
if r is None:
r = aCC/2/sin(al/2)
for i in range(0,nn):
ffi=fi*i
s.appendAtom(0,Vector(x_shift+r*cos(ffi),y_shift+r*sin(ffi),z_shift+shift))
for i in range(0,nn):
ffi=al+fi*i
s.appendAtom(0,Vector(x_shift+r*cos(ffi),y_shift+r*sin(ffi),z_shift+shift))
shift = shift + aCC*sqrt(3.0)/2
for i in range(0,nn):
ffi=al+be+fi*(i)
s.appendAtom(0,Vector(x_shift+r*cos(ffi),y_shift+r*sin(ffi),z_shift+shift))
for i in range(0,nn):
ffi=2*al+be+fi*(i)
s.appendAtom(0,Vector(x_shift+r*cos(ffi),y_shift+r*sin(ffi),z_shift+shift))
shift = shift + aCC*sqrt(3.0)/2
s.basis[0][0] = 2*r+7
s.basis[1][1] = 2*r+7
s.basis[2][2] = shift
s.R = r
return s