Python binary.zinc_blende函数代码示例

def test_B3():
  from numpy import all
  from pylada.ce import cluster_factory
  from pylada.crystal import binary

  def topos(s):
    return lattice[s[1]].pos + s[0]
  # test multi-lattice with different occupations. 
  lattice = binary.zinc_blende()
  lattice[0].type = ['Si', 'Ge']
  lattice[1].type = ['Si', 'Ge', 'C']

  a = cluster_factory(lattice, B3=1)
  assert len(a) == 2
  for cluster in a:
    assert all(abs(abs(topos(cluster.spins[1]) - topos(cluster.spins[0])) - 0.25) < 1e-8)
    assert all(abs(abs(topos(cluster.spins[2]) - topos(cluster.spins[0])) - 0.25) < 1e-8)

  # test multi-lattice with same occupations. 
  lattice = binary.zinc_blende()
  lattice[0].type = ['Si', 'Ge']
  lattice[1].type = ['Si', 'Ge']
  a = cluster_factory(lattice, B3=1)
  assert len(a) == 1
  for cluster in a:
    assert all(abs(abs(topos(cluster.spins[1]) - topos(cluster.spins[0])) - 0.25) < 1e-8)
    assert all(abs(abs(topos(cluster.spins[2]) - topos(cluster.spins[0])) - 0.25) < 1e-8)

def test_occmap():
  from numpy import cos, sin, pi, abs, all
  from pylada.crystal import binary
  from pylada.ce import Cluster

  lattice = binary.zinc_blende()
  for atom in lattice: atom.type = ['Si', 'Ge']

  a = Cluster(lattice)
  mapping = a.occupation_mapping()
  assert len(mapping) == len(lattice)
  assert len(mapping[0]) == 2
  assert len(mapping[1]) == 2
  assert abs(mapping[0]['Si'] - cos(2e0*pi*0e0/2.0)) < 1e-8
  assert abs(mapping[0]['Ge'] - cos(2e0*pi*1e0/2.0)) < 1e-8
  assert abs(mapping[1]['Si'] - cos(2e0*pi*0e0/2.0)) < 1e-8
  assert abs(mapping[1]['Ge'] - cos(2e0*pi*1e0/2.0)) < 1e-8

  lattice = binary.zinc_blende()
  lattice[1].type = ['Si', 'Ge', 'C']
  a = Cluster(lattice)
  mapping = a.occupation_mapping()
  assert len(mapping) == len(lattice)
  assert mapping[0] is None
  assert len(mapping[1]) == len(lattice[1].type)
  assert all(abs(mapping[1]['C']  - [cos(2e0*pi*0e0/3.0), sin(2e0*pi*2e0/3.0)]))
  assert all(abs(mapping[1]['Si'] - [cos(2e0*pi*1e0/3.0), sin(2e0*pi*1e0/3.0)]))
  assert all(abs(mapping[1]['Ge'] - [cos(2e0*pi*2e0/3.0), sin(2e0*pi*2e0/3.0)]))

def test_J1():
  from numpy import all
  from pylada.ce import cluster_factory
  from pylada.crystal import binary

  # test multi-lattice with different occupations. 
  lattice = binary.zinc_blende()
  lattice[0].type = ['Si', 'Ge']
  lattice[1].type = ['Si', 'Ge', 'C']

  a = cluster_factory(lattice, J1=True)
  assert len(a) == 2
  assert all(all(abs(u.spins['position']) < 1e-8) for u in a)
  assert a[0].spins['sublattice'] == 0
  assert a[1].spins['sublattice'] == 1

  # test multi-lattice with same occupations. 
  lattice = binary.zinc_blende()
  lattice[0].type = ['Si', 'Ge']
  lattice[1].type = ['Si', 'Ge']

  a = cluster_factory(lattice, J1=True)
  assert len(a) == 1
  assert all(all(abs(u.spins['position']) < 1e-8) for u in a)
  assert a[0].spins['sublattice'] == 0

def test_B2():
  from numpy import all
  from pylada.ce import cluster_factory
  from pylada.crystal import binary

  # test multi-lattice with different occupations. 
  lattice = binary.zinc_blende()
  lattice[0].type = ['Si', 'Ge']
  lattice[1].type = ['Si', 'Ge', 'C']

  a = cluster_factory(lattice, B2=1)
  assert len(a) == 2
  assert all(a[0].spins['sublattice'] == [0, 1])
  assert all(abs(a[0].spins['position'][0]) < 1e-8)
  vector = a[0].spins[1]
  assert abs(sum((lattice[vector[1]].pos + vector[0])**2) - 3*0.25*0.25) < 1e-8
  assert all(a[1].spins['sublattice'] == [1, 0])
  assert all(abs(a[1].spins['position'][0]) < 1e-8)
  assert all(abs(a[1].spins['position'][1]) < 1e-8)
  a = cluster_factory(lattice, B2=2)
  assert len(a) == 4
  a = cluster_factory(lattice, B2=3)
  assert len(a) == 6

  # test multi-lattice with same occupations. 
  lattice = binary.zinc_blende()
  lattice[0].type = ['Si', 'Ge']
  lattice[1].type = ['Si', 'Ge']

  a = cluster_factory(lattice, B2=1)
  assert len(a) == 1
  a = cluster_factory(lattice, B2=2)
  assert len(a) == 2
  a = cluster_factory(lattice, B2=3)
  assert len(a) == 3

def test_single_counting():
  from pylada.crystal import binary, supercell
  from pylada.vff import build_tree
  a = binary.zinc_blende()
  a = supercell(binary.zinc_blende(), [[4, 0, 0], [0, 2, 0], [0, 0, 1]])
  b = build_tree(a, overlap=0.5)
  
  n = 0
  for center in b:
    for endpoint, vector in center.sc_bond_iter():
      n += 1
      for other, v in endpoint.sc_bond_iter(): assert other is not center
      assert id(center) in [id(c) for c, v in endpoint]
  assert n == 2 * len(a)

def test_onsite():
  """ Tests J0 PI calculation.

      This uses the same algorithmic pathway as more complex figures, but can
      be easily computed as the sum of particular specie-dependent terms on
      each site.  
  """ 
  from numpy import dot, abs, all
  from random import choice
  from pylada.crystal import binary, supercell
  from pylada.ce import Cluster

  lattice = binary.zinc_blende()
  for atom in lattice: atom.type = ['Si', 'Ge', 'C']

  structure = binary.zinc_blende()
  for atom in structure: atom.type = 'Si'

  a = Cluster(lattice)

  # Empty cluster first
  assert abs(a(structure) - len(structure)) < 1e-8
  for i in xrange(10):
    superstructure = supercell(lattice, dot(lattice.cell, get_cell()))
    for atom in superstructure: atom.type = choice(atom.type)
    assert abs(a(superstructure) - len(superstructure)) < 1e-8

  # Try on-site cluster.
  # loop over random supercells.
  # PI should be number of proportional to number of each atomic type on each
  # site, or thereabouts
  mapping = a.occupation_mapping()
  for i in xrange(10):
    # create random superstructure
    superstructure = supercell(lattice, dot(lattice.cell, get_cell()))
    for atom in superstructure: atom.type = choice(atom.type)

    # now first and second site clusters
    for i, site in enumerate(lattice):
      # loop over flavors.
      types = [u.type for u in superstructure]
      a.spins = None
      a.add_spin(site.pos)
      s = mapping[i].itervalues().next().copy()
      s[:] = 0e0
      for t in site.type:
        s += float(types.count(t)) * mapping[i][t]
      assert all(abs(a(superstructure) - s) < 1e-8)

def test_angle():
  from pylada.crystal import binary, supercell
  from pylada.vff import build_tree

  a = binary.zinc_blende()
  a = supercell(binary.zinc_blende(), [[4, 0, 0], [0, 2, 0], [0, 0, 1]])
  b = build_tree(a, overlap=0.5)

  for center in b:
    ids = [id(u.center) for u, d in center]
    angles = set([(id(u.center), id(v.center)) for (u, d), (v, d) in center.angle_iter()])
    for i, ida in enumerate(ids[:-1]):
      for idb in ids[i+1:]:
        if (ida, idb) in angles: assert (idb, ida) not in angles
        else: assert (idb, ida) in angles
    assert len(angles) == 6

def test_translations(cell):
    from numpy import abs, all
    from pylada.crystal import binary, supercell, HFTransform
    from pylada.decorations import Transforms

    lattice = binary.zinc_blende()
    lattice[0].type = ['Si', 'Ge']
    lattice[1].type = ['Si', 'Ge', 'C']

    # create random structure
    structure = supercell(lattice, cell)
    hft = HFTransform(lattice, structure)

    # these are all the translations
    translations = Transforms(lattice).translations(hft)
    assert translations.shape == (len(structure) // len(lattice) - 1, len(structure))
    # compute each translation and gets decorations
    for atom in structure:
        if atom.site != 0:
            continue
        # create translation
        trans = atom.pos - lattice[0].pos
        if all(abs(trans) < 1e-8):
            continue
        # figure out its index
        index = hft.index(trans) - 1
        for site in structure:
            pos = site.pos - lattice[site.site].pos
            i = hft.index(pos, site.site)
            j = hft.index(pos + trans, site.site)
            assert translations[index, i] == j

def test_tree():
  from numpy import all, array, dot, sum, any
  from pylada.crystal import binary, supercell
  from pylada.vff import build_tree
  a = binary.zinc_blende()
  a = supercell(binary.zinc_blende(), [[2, 0, 0], [0, 2, 0], [0, 0, 1]])
  b = build_tree(a, overlap=0.5)
  
  for center in b:
    positions = []
    for i, (bond, vector) in enumerate(center):
      position = bond.pos + dot(a.cell, vector)
      assert abs(sum((position - center.pos)**2) - 0.25*0.25*3) < 1e-8
      assert all( [any(abs(array(p) - position[None, :]) > 1e-8) for p in positions] )
      positions.append(position)
    assert i == 3

def test_labelexchange():
    """ Tests label exchange """
    from pylada.crystal import binary, supercell, HFTransform
    from pylada.decorations import Transforms

    lattice = binary.zinc_blende()
    lattice[0].type = ['Si', 'Ge']
    lattice[1].type = ['Si', 'Ge', 'C']
    transforms = Transforms(lattice)
    lattice = transforms.lattice

    structure = supercell(lattice, [[8, 0, 0], [0, 0.5, 0.5], [0, -0.5, 0.5]])
    species = ['Ge', 'C', 'Si', 'C', 'Si', 'C', 'Si', 'Si', 'Ge', 'Si', 'Ge',
               'Si', 'Ge', 'Si', 'Ge', 'Ge', 'Ge', 'C', 'Ge', 'Si', 'Si', 'Si',
               'Si', 'Ge', 'Si', 'Ge', 'Si', 'Si', 'Si', 'C', 'Ge', 'Si']
    for atom, s in zip(structure, species):
        atom.type = s
    hft = HFTransform(lattice, structure)
    x = transforms.toarray(hft, structure)
    results = [21112222221111123331111231122131,  # <- this is x
               21112222221111122221111321133121,
               21112222221111123332222132211232,
               21112222221111121112222312233212,
               21112222221111122223333123311323,
               21112222221111121113333213322313,
               12221111112222213331111231122131,
               12221111112222212221111321133121,
               12221111112222213332222132211232,
               12221111112222211112222312233212,
               12221111112222212223333123311323,
               12221111112222211113333213322313]
    permutations = transforms.label_exchange(hft)
    for a, b in zip(permutations(x), results[1:]):
        assert int(str(a)[1:-1].replace(' ', '')) == b

def test_random():
  from numpy import dot, all, abs
  from numpy.random import randint
  from random import choice
  from pylada.ce import Cluster
  from pylada.crystal import binary, supercell

  lattice = binary.zinc_blende()
  lattice[0].type = ['Si', 'Ge']
  lattice[1].type = ['Si', 'Ge', 'C']

  # now try random clusters with cell and their supercells
  for i in xrange(10):
    # random cluster
    a = Cluster(lattice)
    site = choice([0, 1])
    a.add_spin(lattice[site].pos)
    for j in xrange(4): 
      site = choice([0, 1])
      pos = lattice[site].pos + dot(lattice.cell, randint(4, size=(3,))-2)
      try: a.add_spin(pos)
      except ValueError: pass

    # random structure
    structure = supercell(lattice, dot(lattice.cell, get_cell(3)))
    for atom in structure: atom.type = choice(lattice[atom.site].type)

    # random supercell
    for j in xrange(5):
      sp = supercell(structure, dot(structure.cell, get_cell(3)))
      for atom in sp: atom.site = structure[atom.site].site
      assert all(abs(a(sp) - len(sp) / len(structure) * a(structure)) < 1e-8)

def test_inas():
  from numpy import identity, abs, all, dot, array
  from pylada.crystal.binary import zinc_blende
  from quantities import eV, angstrom

  vff = functional()

  structure = zinc_blende()
  structure[0].type = 'In'
  structure[1].type = 'As'
  structure.scale = 6.5 #2.62332 * 2 / sqrt(3)  / 0.529177

  out = vff._pyeval(structure)
  assert abs(out.energy - 0.34958768908 * eV) < 1e-8
  assert abs(out.energy - vff.energy(structure)) < 1e-8
  assert all(abs(out.stress - vff.jacobian(structure)[0]) < 1e-8)
  assert all(abs(out.stress - identity(3) * -0.04096678 * eV/angstrom**3) < 1e-8)
  assert all(abs(out[0].gradient) < 1e-8)
  assert all(abs(out[1].gradient) < 1e-8)

  epsilon = array([[1e0, 0.1, 0], [0.1, 1e0, 0], [0, 0, 1e0]])
  structure.cell = dot(epsilon, structure.cell)
  for atom in structure: atom.pos = dot(epsilon, atom.pos)
  out = vff._pyeval(structure)
  assert abs(out.energy - 0.527010806043 * eV) < 1e-8
  assert abs(out.energy - vff.energy(structure)) < 1e-8
  assert all(abs(out.stress - [[ -2.50890474e-02,  -2.95278697e-02,  0],
                               [ -2.95278697e-02,  -2.50890474e-02,  0],
                               [ 0, 0,  -1.85427515e-02]] * eV / angstrom**3) < 1e-6)
  assert all(abs(out.stress - vff.jacobian(structure)[0]) < 1e-8)
  assert all(abs(out[0].gradient - [0, 0, 1.09205526] * eV / angstrom) < 1e-6)
  assert all(abs(out[1].gradient - [0, 0, -1.09205526] * eV / angstrom) < 1e-6)
  assert all(abs([u.gradient for u in out] - vff.jacobian(structure)[1].magnitude) < 1e-8)

def test_disorder(lim=8):
  from numpy import all, array, dot
  from numpy.random import random, randint
  from numpy.linalg import det
  from pylada.crystal import binary, supercell
  from pylada.vff import build_tree


  lattice = binary.zinc_blende()
  for i in xrange(10):
    cell = randint(-lim, lim, (3,3))
    while det(cell) == 0: cell = randint(-lim, lim, (3,3))
    a = supercell(lattice, dot(lattice.cell, cell))
  
    b = build_tree(a, overlap=0.8)
    ids = [id(node.center) for node in b]
    connections = array([ sorted([ids.index(id(n.center)) for n, v in node])
                          for node in b ])
  
    epsilon = random((3,3)) * 0.1
    epsilon = epsilon + epsilon.T
    a.cell += dot(epsilon, a.cell)
    for atom in a: atom.pos += dot(epsilon, atom.pos)
    
    b = build_tree(a, overlap=0.8)
    c = array([ sorted([ids.index(id(n.center)) for n, v in node])
                          for node in b ])
    assert all(connections == c)
    
    b = build_tree(a, overlap=0.8)
    for atom in a: atom.pos += random(3) * 0.05 - 0.025
    c = array([ sorted([ids.index(id(n.center)) for n, v in node])
                          for node in b ])
    assert all(connections == c)
  return a

def test_zb():
  from numpy import all, abs, dot
  from pylada.crystal import space_group, transform, binary
  from pylada.crystal.cppwrappers import equivalent

  structure = binary.zinc_blende()
  ops = space_group(structure)
  assert len(ops) == 24
  for op in ops:
    assert op.shape == (4, 3)

    other = transform(structure, op)
    assert all(abs(dot(op[:3], structure.cell)-other.cell) < 1e-8)
    for a, atom in zip(structure, other):
      assert all(abs(dot(op[:3], a.pos) + op[3] - atom.pos) < 1e-8)
      assert a.type == atom.type

    assert equivalent(structure, other, cartesian=False)
    assert equivalent(other, structure, cartesian=False)
     
  for atom in structure: atom.type = ['A', 'B']
  ops = space_group(structure)
  assert len(ops) == 48
  for op in ops:
    assert op.shape == (4, 3)

    other = transform(structure, op)
    assert all(abs(dot(op[:3], structure.cell)-other.cell) < 1e-8)
    for a, atom in zip(structure, other):
      assert all(abs(dot(op[:3], a.pos) + op[3] - atom.pos) < 1e-8)
      assert a.type == atom.type

    assert equivalent(structure, other, cartesian=False)
    assert equivalent(other, structure, cartesian=False)

def test_cmp():
  """ Test Cluster._contains function """
  from numpy import all, any
  from pylada.crystal import binary
  from pylada.ce import Cluster
  from pylada.ce.cluster import spin

  lattice = binary.zinc_blende()
  lattice[0].type = ['Si', 'Ge']
  lattice[1].type = ['Si', 'Ge', 'C']

  def cmp(a,b):
    if len(a) != len(b): return False
    return all([any([all(v == s) for s in a]) for v in b])

  a = Cluster(lattice)
  a.add_spin(lattice[0].pos)
  assert cmp(a.spins,     [spin([0, 0, 0], 0)])
  assert not cmp(a.spins, [spin([0.5, 0.5, 0.5], 0)])
  assert not cmp(a.spins, [spin([0, 0, 0], 1)])
  a = Cluster(lattice)
  a.add_spin(lattice[1].pos)
  assert cmp(a.spins,     [spin([0, 0, 0], 1)])
  assert not cmp(a.spins, [spin([0.5, 0.5, 0.5], 1)])
  assert not cmp(a.spins, [spin([0, 0, 0], 0)])
  a.add_spin(lattice[0].pos)
  assert cmp(a.spins,     [spin([0, 0, 0], 1), spin([0, 0, 0])])
  assert cmp(a.spins,     [spin([0, 0, 0]), spin([0, 0, 0], 1)])
  assert not cmp(a.spins, [spin([0, 0, 0], 1), spin([0, 0, 0]), spin([1, 0, 0])])
  assert not cmp(a.spins, [spin([1, 0, 0]), spin([0, 0, 0], 1)])