Пример #1
0
def read_shape(shape, shape_atom, layers, atom_dict):
    import numpy as np
    import pymatgen as mg
    import os
    from objects import atom

    dir_path = os.path.dirname(os.path.realpath(__file__))

    # opening shapes file
    with open(os.path.join(dir_path, 'shapes/' + shape)) as f:
        tag = f.readline()
        try:
            c = int(tag.split()[1])
        except IndexError:
            c = 0
        mg_atom = mg.Element(shape_atom)

        # adding core layer if specified
        for j in range(c):
            coords = np.array(list(map(
                float,
                f.readline().split()))) * mg_atom.atomic_radius
            atom_dict[len(atom_dict)] = atom(mg_atom,
                                             coords,
                                             num=len(atom_dict),
                                             c_tag='b')

        # adding given layers to global layers list
        layers.append([atom_dict[i] for i in range(c)])
        print('Core layer created, atoms:', len(layers[0]))

        # adding outer shell (rest of the atoms)
        for line in f:
            coords = np.array(list(map(float, line.split()))) * float(
                mg_atom.atomic_radius)
            atom_dict[len(atom_dict)] = atom(mg_atom,
                                             coords,
                                             num=len(atom_dict),
                                             c_tag='b')

        layers.append([atom_dict[i] for i in range(c, len(atom_dict))])
        print('Shell layer created, atoms:', len(layers[-1]))
Пример #2
0
def read_poscar(layers, atom_dict):
    from pymatgen import Structure, Element
    from objects import atom

    name = (input('Enter Name of POSCAR file in the same directory: '))
    poscar = Structure.from_file(name)
    for i in poscar:
        mg_atom = Element(str(i.specie))
        atom_dict[len(atom_dict)] = atom(mg_atom,
                                         list(i.coords),
                                         num=len(atom_dict),
                                         c_tag='b')
    layers.append([atom_dict[i] for i in atom_dict])
    print('Read POSCAR as a single layer')
    cmd = input('add layer <l> or add adsorbate <a>? ')
    while cmd == 'l':
        sym = input("Which atom to deposit? ")
        add_layer(Element(sym))
        cmd = input('add layer <l> or add adsorbate <a>? ')

    if cmd == 'a':
        add_ads(layers[-1], Element(sym))
Пример #3
0
def gen_ads_sites(layer, ads):
    """
    Input:
        layer: an outer layer (atoms shouldn't be missing, extra is fine)
        ads: pymatgen atom object
    Output:
        list of all atom objects WITH ROOTS
    """

    # T package returns indices of atoms to be considered
    ttd_indices = DT([i.ic for i in layer.atom_list])

    tol_h = 0.01  # float(input('Enter minimum height of a tetrahedral formed on surface (0.01)\n'))
    tol_d = 3 * layer.atom_list[
        0].radius  # float(input('Enter maximum distance between two surface atoms (3*atomic_radius testing)\n'))

    # dict for all_ttd
    all_ttd = []

    # rc (return coord) returns the coords of concerned index
    rc = lambda x: layer.atom_list[x].ic

    # making all ttds in ttd objects
    for i in ttd_indices:

        ttd_coord = [rc(j) for j in i]
        print(ttd_coord)

        # adding ttd objects to all_ttd
        all_ttd.append(ttd(i, ttd_coord, tol_d, tol_h))

    # faces_indices will have list of lists of relative face indices
    faces_indices = []

    # checking if ttd holds for all requirements of making surface
    # ttd object KNOWS if it is legit and on surface
    for i in all_ttd:
        if i.is_surface(all_ttd):
            faces_indices.append[i.face]

    # deleting all_ttd and rc, as not needed now
    del all_ttd, rc

    ar = ads.atomic_radius
    lr = layer.atom_list[0].atomic_radius

    #  a list of sites [atom objects WITH ROOTS]
    sites = []

    # keeps track of previously considered atoms to avoid repitions
    roots = []

    def return_atom(x):
        # return atom indexed x from the atom_list of layer
        return layer.atom_list[x]

    # add ontop adsorbate sites
    # simply add on all atoms on surface (no repititions)
    for i in faces_indices:
        for j in i:
            root = j
            if root not in roots:
                roots.append(root)
                c = return_atom(j).ic
                cn = unit(c)
                d = (ar + lr) * cn
                new = c + d
                sites.append(atom(ads, new, root=[return_atom(j)]))

    # add bridge elements
    # initializing roots (not necessary)
    roots = []
    comb = [[0, 1], [0, 2], [1, 2]]

    for F in faces_indices:
        for i in comb:

            # root is a set so order doesn't matter
            root = {F[j] for j in i}

            if root not in roots:

                # adding root to roots so that it is not repeated
                roots.append(root)

                # getting atoms to add a new bridge atom
                A = layer.atom_list[faces_indices[i[0]]].ic
                B = layer.atom_list[faces_indices[i[1]]].ic

                # midpoint
                C = (A + B) / 2
                c = unit(C)
                d = ar + lr
                r = linalg.norm(A - B)

                # only if atom is too big to sit at midpoint
                if d > r / 2:
                    new = C + c * pow((pow(d, 2) - pow(r / 2, 2)), 0.5)

                # else same coordinates are used irrespective of size
                else:
                    new = C

                sites.append(
                    atom(ads, new, root=[return_atom(x) for x in root]))

    # initializing roots (not necessary)
    roots = []

    # func checks if a face is square like (then no hcc/hcp site is added)
    def is_squarelike(F):
        C = [return_atom(x).ec for x in F]
        comb = [[0, 1, 2], [1, 0, 2], [2, 1, 0]]
        for i in comb:
            a = unit(C[i[1]] - C[i[0]])
            b = unit(C[i[2]] - C[i[0]])

            # if angle is more than 75
            if abs(dot(a, b)) < 0.258:
                return 1

            # else check other comb
            else:
                continue

        # if all angles less than 75, must be equilateral tri
        else:
            return 0

    # add fcc/hcp elements
    for F in faces_indices:
        root = set(F)
        if root not in roots:
            if is_squarelike(F):
                pass
            else:
                A = return_atom(F[0]).ic
                B = return_atom(F[1]).ic
                C = return_atom(F[2]).ic
                D = (A + B + C) / 3
                d = unit(D)
                e = linalg.norm(A - B)
                new = D + d * (pow(2 / 3, 0.5) * e)
                sites.append(
                    atom(ads,
                         new,
                         c_tag='i',
                         root=[return_atom(x) for x in root]))
    return sites
Пример #4
0
import objects

'''
!!!!! VERY IMPORTANT !!!!!!!!!
"none" in python does not mean that there is 
no weight, etc. it means that there is no value
to put there. Likley that it is unknown
"none" means "unknown"
'''

def pack_atom_to_numbers(atom) :
 return 10000000 + atom.atomic_number * 10000 + atom.column * 100 + atom.row * 10 + atom.valence


sulfur = objects.atom(16, 16, 3, 6)

print(pack_atom_to_numbers(sulfur))
Пример #5
0
from objects import Atom, Compound, Variable, atom
from rpython.rlib import rfile
import machine
import parser
import os


def new_entry_point(config):
    return main


MAIN = atom("main", 0)


def main(argv):
    if len(argv) <= 1:
        return 1

    fd = rfile.create_file(argv[1], 'rb')
    try:
        source = fd.read()
    finally:
        fd.close()

    code, next_varno = parser.parse(source)
    program = machine.load(code)
    succ = machine.Success()
    try:
        program.solve(succ, Compound(MAIN, []), next_varno)
    except machine.Exiting as exit:
        return exit.status
Пример #6
0
from objects import Atom, Compound, Integer, Variable
from objects import known_atoms, atom, as_list, wrap
from objects import CONS, NIL, AND, OR, TRUE, FALSE, failure, success
from objects import Trail, UNIFY_ATTS, BIND_HARD
from objects import DepthFirstSearch, OrderedSearch
import os

CLAUSE = atom("<-", 2)
CONSTRAINT_RULE = atom("constraint_rule", 5)

SAME = atom("same", 2)
UNIFY = atom("=", 2)
COND2 = atom("cond", 2)
DEF = atom("DEF", 2)


def load(code, varno=100, debug=False):
    defs = {}
    chrs = []
    constraints = {}
    occurrenceno = 0
    for clause in reversed(as_list(code)):
        assert isinstance(clause, Compound)
        if clause.fsym is CLAUSE:
            head = clause.args[0]
            assert isinstance(head, Compound)
            if head.fsym in defs:
                rest = defs[head.fsym]
            else:
                rest = Compound(NIL, [])
            defs[head.fsym] = Compound(CONS, [clause, rest])