Chimie Théorique » QMX

# encoding: utf-8

"""surfaceslab.py - Window for setting up surfaces

"""

import gtk

from ase.gui.widgets import pack, cancel_apply_ok, oops

from ase.gui.pybutton import PyButton

from ase.gui.setupwindow import SetupWindow

import ase.lattice.surface as _surf

import ase

import numpy as np

introtext = """\

  Use this dialog to create surface slabs.  Select the element by

writing the chemical symbol or the atomic number in the box.  Then

select the desired surface structure.  Note that some structures can

be created with an othogonal or a non-orthogonal unit cell, in these

cases the non-orthogonal unit cell will contain fewer atoms.

  If the structure matches the experimental crystal structure, you can

look up the lattice constant, otherwise you have to specify it

yourself."""

# Name, structure, orthogonal, support-nonorthogonal, function

surfaces = [('FCC(100)', 'fcc', True, False, _surf.fcc100),

            ('FCC(110)', 'fcc', True, False, _surf.fcc110),

            ('FCC(111) non-orthogonal', 'fcc', False, True, _surf.fcc111),

            ('FCC(111) orthogonal', 'fcc', True, True, _surf.fcc111),

            ('BCC(100)', 'bcc', True, False, _surf.bcc100),

            ('BCC(110) non-orthogonal', 'bcc', False, True, _surf.bcc110),

            ('BCC(110) orthogonal', 'bcc', True, True, _surf.bcc110),

            ('BCC(111) non-orthogonal', 'bcc', False, True, _surf.bcc111),

            ('BCC(111) orthogonal', 'bcc', True, True, _surf.bcc111),

            ('HCP(0001) non-orthogonal', 'hcp', False, True, _surf.hcp0001),

            ('HCP(0001) orthogonal', 'hcp', True, True, _surf.hcp0001),

            ]

py_template = """

from ase.lattice.surface import %(func)s

atoms = %(func)s(symbol='%(symbol)s', size=%(size)s,

    a=%(a).3f, vacuum=%(vacuum).3f%(orthoarg)s)

"""

class SetupSurfaceSlab(SetupWindow):

    """Window for setting up a surface."""

    def __init__(self, gui):

        SetupWindow.__init__(self)

        self.set_title("Surface")

        self.atoms = None

        vbox = gtk.VBox()

        # Intoductory text

        self.packtext(vbox, introtext)

        # Choose the element

        label = gtk.Label("Element: ")

        element = gtk.Entry(max=3)

        self.element = element

        self.elementinfo = gtk.Label("")

        pack(vbox, [label, element, self.elementinfo])

        self.element.connect('activate', self.update)

        self.legal_element = False

        # Choose the surface structure

        label = gtk.Label("Structure: ")

        self.structchoice = gtk.combo_box_new_text()

        self.surfinfo = {}

        for s in surfaces:

            assert len(s) == 5

            self.structchoice.append_text(s[0])

            self.surfinfo[s[0]] = s

        pack(vbox, [label, self.structchoice])

        self.structchoice.connect('changed', self.update)

        # Choose the lattice constant

        tbl = gtk.Table(2, 3)

        label = gtk.Label("Lattice constant: ")

        tbl.attach(label, 0, 1, 0, 1)

        vbox2 = gtk.VBox()          # For the non-HCP stuff

        self.vbox_hcp = gtk.VBox()  # For the HCP stuff.

        self.lattice_const = gtk.Adjustment(3.0, 0.0, 1000.0, 0.01)

        lattice_box = gtk.SpinButton(self.lattice_const, 10.0, 3)

        lattice_box.numeric = True

        pack(vbox2, [gtk.Label("a:"), lattice_box, gtk.Label("Å")])

        tbl.attach(vbox2, 1, 2, 0, 1)

        lattice_button = gtk.Button("Get from database")

        tbl.attach(lattice_button, 2, 3, 0, 1)

        # HCP stuff

        self.hcp_ideal = (8.0/3)**(1.0/3)

        self.lattice_const_c = gtk.Adjustment(self.lattice_const.value * self.hcp_ideal,

                                              0.0, 1000.0, 0.01)

        lattice_box_c = gtk.SpinButton(self.lattice_const_c, 10.0, 3)

        lattice_box_c.numeric = True

        pack(self.vbox_hcp, [gtk.Label("c:"), lattice_box_c, gtk.Label("Å")])

        self.hcp_c_over_a_format = "c/a: %.3f (%.1f %% of ideal)"

        self.hcp_c_over_a_label = gtk.Label(self.hcp_c_over_a_format % (self.hcp_ideal,

                                                                        100.0))

        pack(self.vbox_hcp, [self.hcp_c_over_a_label])

        tbl.attach(self.vbox_hcp, 1, 2, 1, 2)

        tbl.show_all()

        pack(vbox, [tbl])

        self.lattice_const.connect('value-changed', self.update)

        self.lattice_const_c.connect('value-changed', self.update)

        lattice_button.connect('clicked', self.get_lattice_const)

        pack(vbox, gtk.Label(""))

        # System size

        self.size = [gtk.Adjustment(1, 1, 100, 1) for i in range(3)]

        buttons = [gtk.SpinButton(s, 0, 0) for s in self.size]

        self.vacuum = gtk.Adjustment(10.0, 0, 100.0, 0.1)

        vacuum_box = gtk.SpinButton(self.vacuum, 0.0, 1)

        pack(vbox, [gtk.Label("Size: \tx: "), buttons[0],

                    gtk.Label(" unit cells")])

        pack(vbox, [gtk.Label("\t\ty: "), buttons[1],

                    gtk.Label(" unit cells")])

        pack(vbox, [gtk.Label("      \t\tz: "), buttons[2],

                    gtk.Label(" layers,  "),

                    vacuum_box, gtk.Label(" Å vacuum")])

        self.nosize = "\t\tNo size information yet."

        self.sizelabel = gtk.Label(self.nosize)

        pack(vbox, [self.sizelabel])

        for s in self.size:

            s.connect('value-changed', self.update)

        self.vacuum.connect('value-changed', self.update)

        pack(vbox, gtk.Label(""))

        # Buttons

        self.pybut = PyButton("Creating a surface slab.")

        self.pybut.connect('clicked', self.update)

        buts = cancel_apply_ok(cancel=lambda widget: self.destroy(),

                               apply=self.apply,

                               ok=self.ok)

        pack(vbox, [self.pybut, buts], end=True, bottom=True)

        self.add(vbox)

        vbox.show()

        self.show()

        self.gui = gui

        # Hide the HCP stuff to begin with.

        self.vbox_hcp.hide_all()

    # update_element inherited from SetupWindow

    def update(self, *args):

        "Called when something has changed."

        struct = self.structchoice.get_active_text()

        if struct:

            structinfo = self.surfinfo[struct]

            if structinfo[1] == 'hcp':

                self.vbox_hcp.show_all()

                ca = self.lattice_const_c.value / self.lattice_const.value

                self.hcp_c_over_a_label.set_text(self.hcp_c_over_a_format %

                                                 (ca, 100 * ca / self.hcp_ideal))

            else:

                self.vbox_hcp.hide_all()

        # Abort if element or structure is invalid

        if not (self.update_element() and struct):

            self.sizelabel.set_text(self.nosize)

            self.atoms = None

            self.pybut.python = None

            return False

        # Make the atoms

        assert self.legal_element

        kw = {}

        kw2 = {}

        if structinfo[3]:  # Support othogonal keyword?

            kw['orthogonal'] = structinfo[2]

            kw2['orthoarg'] = ', orthogonal='+str(kw['orthogonal'])

        else:

            kw2['orthoarg'] = ''

        kw2['func'] = structinfo[4].__name__

        kw['symbol'] = self.legal_element

        kw['size'] = [int(s.value) for s in self.size]

        kw['a'] = self.lattice_const.value

        kw['vacuum'] = self.vacuum.value

        # Now create the atoms

        try:

            self.atoms = structinfo[4](**kw)

        except ValueError, e:

            # The values were illegal - for example some size

            # constants must be even for some structures.

            self.pybut.python = None

            self.atoms = None

            self.sizelabel.set_text(str(e).replace(".  ", ".\n"))

            return False

        kw2.update(kw)

        self.pybut.python = py_template % kw2

        # Find the heights of the unit cell

        h = np.zeros(3)

        uc = self.atoms.get_cell()

        for i in range(3):

            norm = np.cross(uc[i-1], uc[i-2])

            norm /= np.sqrt(np.dot(norm, norm))

            h[i] = np.abs(np.dot(norm, uc[i]))

        natoms = len(self.atoms)

        txt = ("\t\t%.2f Å x %.2f Å x %.2f Å,  %i atoms."

               % (h[0], h[1], h[2], natoms))

        self.sizelabel.set_text(txt)

        return True

    def get_lattice_const(self, *args):

        if not self.update_element():

            oops("Invalid element.")

            return

        z = ase.atomic_numbers[self.legal_element]

        ref = ase.data.reference_states[z]

        surface = self.structchoice.get_active_text()

        if not surface:

            oops("No structure specified!")

            return

        struct = self.surfinfo[surface][1]

        if ref is None or ref['symmetry'].lower() != struct:

            oops(struct.upper() + " lattice constant unknown for "

                      + self.legal_element + ".")

            return

        a = ref['a']

        self.lattice_const.set_value(a)

        if struct == 'hcp':

            c = ref['c/a'] * a

            self.lattice_const_c.set_value(c)

    def apply(self, *args):

        self.update()

        if self.atoms is not None:

            self.gui.new_atoms(self.atoms)

            return True

        else:

            oops("No valid atoms.",

                 "You have not (yet) specified a consistent set of parameters.")

            return False

    def ok(self, *args):

        if self.apply():

            self.destroy()