def __init__(self, gui):
gtk.Window.__init__(self)
self.set_title(_('DFT'))
vbox = gtk.VBox()
combo = gtk.combo_box_new_text()
self.xcfuncs = 'None LDA PBE revPBE RPBE PW91 EXX PBE0'.split()
for xc in self.xcfuncs:
combo.append_text(xc)
pack(vbox, [gtk.Label(_('XC-functional: ')), combo])
button = radio(None, monkhorstpack)
button = radio(button, special)
pack(vbox, gtk.Label(_('Repeat atoms:')))
self.kpts = [gtk.Adjustment(r, 1, 99, 1) for r in gui.atoms.repeat]
pack(vbox, [gtk.SpinButton(r, 0, 0) for r in self.repeat])
for r in self.repeat:
r.connect('value-changed', self.change)
close = pack(vbox, gtk.Button(_('Close')))
close.connect('clicked', lambda widget: self.destroy())
self.add(vbox)
vbox.show()
self.show()
self.gui = gui
xc = gui.atoms.dft.get('xc', 'None')
combo.set_active(self.xcfuncs.index(xc))
def __init__(self, gui):
gtk.Window.__init__(self)
self.set_position(gtk.WIN_POS_NONE)
self.connect('destroy', self.close)
#self.connect('delete_event', self.exit2)
self.set_title('Movie')
vbox = gtk.VBox()
pack(vbox, gtk.Label(_('Image number:')))
self.frame_number = gtk.Adjustment(gui.frame, 0,
gui.images.nimages - 1, 1.0, 5.0)
self.frame_number.connect('value-changed', self.new_frame)
hscale = pack(vbox, gtk.HScale(self.frame_number))
hscale.set_update_policy(gtk.UPDATE_CONTINUOUS)
hscale.set_digits(0)
buttons = [
gtk.Button(stock=gtk.STOCK_GOTO_FIRST),
gtk.Button(stock=gtk.STOCK_GO_BACK),
gtk.Button(stock=gtk.STOCK_GO_FORWARD),
gtk.Button(stock=gtk.STOCK_GOTO_LAST)
]
buttons[0].connect('clicked', self.click, -10000000)
buttons[1].connect('clicked', self.click, -1)
buttons[2].connect('clicked', self.click, 1)
buttons[3].connect('clicked', self.click, 10000000)
pack(vbox, buttons)
play, stop = pack(vbox, [gtk.Button(_('Play')), gtk.Button('Stop')])
play.connect('clicked', self.play)
stop.connect('clicked', self.stop)
self.rock = pack(vbox, gtk.CheckButton('Rock'))
self.time = gtk.Adjustment(2.0, 0.5, 9.0, 0.2)
hscale = pack(vbox, gtk.HScale(self.time))
hscale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
self.time.connect('value-changed', self.new_time)
self.add(vbox)
if gtk.pygtk_version < (2, 12):
self.set_tip = gtk.Tooltips().set_tip
self.set_tip(hscale, _('Adjust play time.'))
else:
hscale.set_tooltip_text(_('Adjust play time.'))
vbox.show()
self.show()
self.gui = gui
#gui.m=self
self.direction = 1
self.id = None
gui.register_vulnerable(self)
def __init__(self, vbox):
self.eventbox = gtk.EventBox()
self.label = gtk.Label()
self.eventbox.add(self.label)
self.label.show()
if gtk.pygtk_version < (2, 12):
self.set_tip(self.eventbox, _('Tip for status box ...'))
else:
self.eventbox.set_tooltip_text(_('Tip for status box ...'))
pack(vbox, self.eventbox)
self.ordered_indices = []
def __init__(self, text):
gtk.Window.__init__(self)
vbox = gtk.VBox()
self.add(vbox)
label = pack(vbox, gtk.Label())
label.set_line_wrap(True)
text = _(text).replace('<c>', '<span foreground="blue">')
text = text.replace('</c>', '</span>')
label.set_markup(text)
close = pack(vbox, gtk.Button(_('Close')))
close.connect('clicked', lambda widget: self.destroy())
self.show_all()
def __init__(self, menubar, name, items):
self.items = {}
menu = gtk.Menu()
for data in items:
text = data[0]
callback = data[1]
args = data[2:]
menuitem = gtk.MenuItem(_(text))
menu.append(menuitem)
menuitem.connect('activate', callback, *args)
menuitem.show()
self.items[text] = menuitem
menuitem = gtk.MenuItem(_(name))
menubar.append(menuitem)
menuitem.set_submenu(menu)
menuitem.show()
def __init__(self, gui):
gtk.Window.__init__(self)
self.set_title('Repeat')
vbox = gtk.VBox()
pack(vbox, gtk.Label(_('Repeat atoms:')))
self.repeat = [gtk.Adjustment(r, 1, 9, 1) for r in gui.images.repeat]
pack(vbox, [gtk.SpinButton(r, 0, 0) for r in self.repeat])
for r in self.repeat:
r.connect('value-changed', self.change)
button = pack(vbox, gtk.Button('Set unit cell'))
button.connect('clicked', self.set_unit_cell)
self.add(vbox)
vbox.show()
self.show()
self.gui = gui
def import_atoms (self, button=None, filenames=None):
if filenames == None:
chooser = gtk.FileChooserDialog(
_('Open ...'), None, gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
ok = chooser.run()
if ok == gtk.RESPONSE_OK:
filenames = [chooser.get_filename()]
chooser.destroy()
if not ok:
return
self.images.import_atoms(filenames, self.frame)
self.set_colors()
self.set_coordinates(self.images.nimages - 1, focus=True)
def open(self, button=None, filenames=None):
if filenames == None:
chooser = gtk.FileChooserDialog(
_('Open ...'), None, gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
ok = chooser.run() == gtk.RESPONSE_OK
if ok:
filenames = [chooser.get_filename()]
chooser.destroy()
if not ok:
return
self.reset_tools_modes()
self.images.read(filenames, slice(None))
self.set_colors()
self.set_coordinates(self.images.nimages - 1, focus=True)
def __init__(self, gui):
self.gui = gui
gtk.Window.__init__(self)
self.set_title(_('Constraints'))
vbox = gtk.VBox()
b = pack(vbox,
[gtk.Button(_('Constrain')),
gtk.Label(_(' selected atoms'))])[0]
b.connect('clicked', self.selected)
b = pack(
vbox,
[gtk.Button(_('Constrain')),
gtk.Label(_(' immobile atoms:'))])[0]
b.connect('clicked', self.immobile)
b = pack(vbox, gtk.Button('Clear constraint'))
b.connect('clicked', self.clear)
close = pack(vbox, gtk.Button(_('Close')))
close.connect('clicked', lambda widget: self.destroy())
self.add(vbox)
vbox.show()
self.show()
def help(text):
button = gtk.Button(_('Help'))
button.connect('clicked', lambda widget, text=text: Help(text))
return button
def save(self, action):
chooser = gtk.FileChooserDialog(
_('Save ...'), None, gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE, gtk.RESPONSE_OK))
# Add a file type filter
types = []
name_to_suffix = {}
for name, suffix in [('Automatic', None),
('XYZ file', 'xyz'),
('ASE trajectory', 'traj'),
('PDB file', 'pdb'),
('Gaussian cube file', 'cube'),
('Python script', 'py'),
('VNL file', 'vnl'),
('Portable Network Graphics', 'png'),
('Persistance of Vision', 'pov'),
('Encapsulated PostScript', 'eps'),
('FHI-aims geometry input', 'in'),
('VASP geometry input', 'POSCAR')]:
if suffix is None:
name = _(name)
else:
name = '%s (%s)' % (_(name), suffix)
filt = gtk.FileFilter()
filt.set_name(name)
if suffix is None:
filt.add_pattern('*')
elif suffix == 'POSCAR':
filt.add_pattern('*POSCAR*')
else:
filt.add_pattern('*.'+suffix)
if suffix is not None:
types.append(suffix)
name_to_suffix[name] = suffix
chooser.add_filter(filt)
if self.images.nimages > 1:
img_vbox = gtk.VBox()
button = gtk.CheckButton('Save current image only (#%d)' %
self.frame)
pack(img_vbox, button)
entry = gtk.Entry(10)
pack(img_vbox, [gtk.Label(_('Slice: ')), entry,
help('Help for slice ...')])
entry.set_text('0:%d' % self.images.nimages)
img_vbox.show()
chooser.set_extra_widget(img_vbox)
while True:
# Loop until the user selects a proper file name, or cancels.
response = chooser.run()
if response == gtk.RESPONSE_CANCEL:
chooser.destroy()
return
elif response != gtk.RESPONSE_OK:
print("AG INTERNAL ERROR: strange response in Save,", response, file=sys.stderr)
chooser.destroy()
return
filename = chooser.get_filename()
suffix = os.path.splitext(filename)[1][1:]
if 'POSCAR' in filename:
suffix = 'POSCAR'
if suffix == '':
# No suffix given. If the user has chosen a special
# file type, use the corresponding suffix.
filt = chooser.get_filter().get_name()
suffix = name_to_suffix[filt]
filename = filename + '.' + suffix
if suffix not in types:
oops(message='Unknown output format!',
message2='Use one of: ' + ', '.join(types[1:]))
continue
if self.images.nimages > 1:
if button.get_active():
filename += '@%d' % self.frame
else:
filename += '@' + entry.get_text()
break
chooser.destroy()
bbox = np.empty(4)
size = np.array([self.width, self.height]) / self.scale
bbox[0:2] = np.dot(self.center, self.axes[:, :2]) - size / 2
bbox[2:] = bbox[:2] + size
suc = self.ui.get_widget('/MenuBar/ViewMenu/ShowUnitCell').get_active()
self.images.write(filename, self.axes, show_unit_cell=suc, bbox=bbox)
def add_atoms(self, widget, data=None):
"""
Presents a dialogbox to the user, that allows him to add atoms/molecule to the current slab.
The molecule/atom is rotated using the current rotation of the coordinate system.
The molecule/atom can be added at a specified position - if the keyword auto+Z is used,
the COM of the selected atoms will be used as COM for the moleculed. The COM is furthermore
translated Z ang towards the user.
If no molecules are selected, the COM of all the atoms will be used for the x-y components of the
active coordinate system, while the z-direction will be chosen from the nearest atom position
along this direction.
Note: If this option is used, all frames except the active one are deleted.
"""
if data:
if data == 'load':
chooser = gtk.FileChooserDialog(
_('Open ...'), None, gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
ok = chooser.run()
if ok == gtk.RESPONSE_OK:
filename = chooser.get_filename()
chooser.destroy()
if not ok:
return
if data == 'OK' or data == 'load':
import ase
if data == 'load':
molecule = filename
else:
molecule = self.add_entries[1].get_text()
tag = self.add_entries[2].get_text()
mom = self.add_entries[3].get_text()
pos = self.add_entries[4].get_text().lower()
a = None
try:
a = ase_ext.Atoms([ase.Atom(molecule)])
except:
try:
a = ase_ext.molecule(molecule)
except:
try:
a = ase_ext.read(molecule, -1)
except:
self.add_entries[1].set_text('?' + molecule)
return ()
directions = np.transpose(self.axes)
if a != None:
for i in a:
try:
i.set_tag(int(tag))
except:
self.add_entries[2].set_text('?' + tag)
return ()
try:
i.magmom = float(mom)
except:
self.add_entries[3].set_text('?' + mom)
return ()
# apply the current rotation matrix to A
for i in a:
i.position = np.dot(self.axes, i.position)
# find the extent of the molecule in the local coordinate system
a_cen_pos = np.array([0.0, 0.0, 0.0])
m_cen_pos = 0.0
for i in a.positions:
a_cen_pos[0] += np.dot(directions[0], i)
a_cen_pos[1] += np.dot(directions[1], i)
a_cen_pos[2] += np.dot(directions[2], i)
m_cen_pos = max(np.dot(-directions[2], i), m_cen_pos)
a_cen_pos[0] /= len(a.positions)
a_cen_pos[1] /= len(a.positions)
a_cen_pos[2] /= len(a.positions)
a_cen_pos[2] -= m_cen_pos
# now find the position
cen_pos = np.array([0.0, 0.0, 0.0])
if sum(self.images.selected) > 0:
for i in range(len(self.R)):
if self.images.selected[i]:
cen_pos += self.R[i]
cen_pos /= sum(self.images.selected)
elif len(self.R) > 0:
px = 0.0
py = 0.0
pz = -1e6
for i in range(len(self.R)):
px += np.dot(directions[0], self.R[i])
py += np.dot(directions[1], self.R[i])
pz = max(np.dot(directions[2], self.R[i]), pz)
px = (px/float(len(self.R)))
py = (py/float(len(self.R)))
cen_pos = directions[0] * px + \
directions[1] * py + \
directions[2] * pz
if 'auto' in pos:
pos = pos.replace('auto', '')
import re
pos = re.sub('\s', '', pos)
if '(' in pos:
sign = eval('%s1' % pos[0])
a_cen_pos -= sign * np.array(eval(pos[1:]), float)
else:
a_cen_pos -= float(pos) * directions[2]
else:
cen_pos = np.array(eval(pos))
for i in a:
i.position += cen_pos - a_cen_pos
# and them to the molecule
atoms = self.images.get_atoms(self.frame)
atoms = atoms + a
self.new_atoms(atoms, init_magmom=True)
# and finally select the new molecule for easy moving and rotation
for i in range(len(a)):
self.images.selected[len(atoms) - i - 1] = True
self.draw()
self.add_entries[0].destroy()
if data == None:
molecule = ''
tag = '0'
mom = '0'
pos = 'auto+1'
self.add_entries = []
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.add_entries.append(window)
window.set_title('Add atoms')
vbox = gtk.VBox(False, 0)
window.add(vbox)
vbox.show()
pack = False
for i, j in [['Insert atom or molecule', molecule],
['Tag', tag],
['Moment', mom],
['Position', pos]]:
label = gtk.Label(i)
if not pack:
vbox.pack_start(label, True, True, 0)
else:
pack = True
vbox.add(label)
label.show()
entry = gtk.Entry()
entry.set_text(j)
self.add_entries.append(entry)
entry.set_max_length(50)
entry.show()
vbox.add(entry)
button = gtk.Button('_Load molecule')
button.connect('clicked', self.add_atoms, 'load')
button.show()
vbox.add(button)
button = gtk.Button('_OK')
button.connect('clicked', self.add_atoms, 'OK')
button.show()
vbox.add(button)
button = gtk.Button('_Cancel')
button.connect('clicked', self.add_atoms, 'Cancel')
button.show()
vbox.add(button)
window.show()
def __init__(self, gui):
gtk.Window.__init__(self)
self.set_title('Settings')
self.gui = gui
vbox = gtk.VBox()
# Constraints
a = pack(vbox, gtk.Label())
a.set_markup('<span size="larger" underline="single">'
'Constraints:</span>')
a, b = pack(vbox, [
gtk.Button(_('Constrain')),
gtk.Label('/'),
gtk.Button(_('release')),
gtk.Label(_(' selected atoms'))
])[::2]
a.connect('clicked', self.constrain_selected)
b.connect('clicked', self.release_selected)
a = pack(vbox, gtk.Button(_('Constrain immobile atoms')))
a.connect('clicked', self.immobile)
a = pack(vbox, gtk.Button(_('Clear all constraints')))
a.connect('clicked', self.clear_constraints)
# Visibility
a = pack(vbox, gtk.Label())
a.set_markup('\n<span size="larger" underline="single">'
'Visibility:</span>')
a, b = pack(vbox, [
gtk.Button(_('Hide')),
gtk.Label('/'),
gtk.Button(_('show')),
gtk.Label(_(' selected atoms'))
])[::2]
a.connect('clicked', self.hide_selected)
b.connect('clicked', self.show_selected)
a = pack(vbox, gtk.Button(_('View all atoms')))
a.connect('clicked', self.view_all)
# Miscellaneous
a = pack(vbox, gtk.Label())
a.set_markup('\n<span size="larger" underline="single">'
'Miscellaneous:</span>')
self.scale = gtk.Adjustment(value=.89,
lower=0.2,
upper=2.0,
step_incr=0.1,
page_incr=0.5)
pack(vbox, [
gtk.Label(_('Scale atomic radii:')),
gtk.SpinButton(self.scale, climb_rate=0, digits=2)
])
self.scale.connect('value-changed', self.scale_radii)
# A close button
pack(vbox, gtk.Label(_('\n')))
close = pack(vbox, gtk.Button(_('Close')))
close.connect('clicked', lambda widget: self.destroy())
# Add elements and show frame
self.add(vbox)
vbox.show()
self.show()
