def choose_structures( _howmany, _min = 2, _max = 9 ): import random import numpy as np from pylada import crystal, enumeration lattice, str_list = list_all_structures( _min, _max ) for i in xrange(_howmany): nsupercell = random.randint(0, len(str_list)-1) while len(str_list[nsupercell][3]) == 0: nsupercell = random.randint(0, len(str_list)-1) nstr = 0 if len(str_list[nsupercell][3]) > 1: nstr = random.randint(0, len(str_list[nsupercell][3])-1) supercell, flavorbase, smith = str_list[nsupercell][:3] x = str_list[nsupercell][3].pop(nstr) # creates structure structure = crystal.sStructure() structure.cell = np.dot(lattice.cell, supercell.hermite) crystal.fill_structure(structure) structure.scale = lattice.scale enumeration.as_structure(structure, x, flavorbase) yield crystal.Structure(structure)
def create_superstructure(groundstate, input): """ Creates a superstructure from existing structure. """ from os.path import dirname, join from operator import itemgetter from numpy import dot from IPython.ipapi import get as get_ipy from pylada.crystal import fill_structure, vasp_ordered # sanity checks, assert "structure" in groundstate.jobparams,\ ValueError("Could not find structure in ground-state job-dictionary.") assert hasattr(groundstate.functional, "Extract"),\ ValueError("Could not find extraction class in ground-state job-dictionary.") ip = get_ipy() assert "current_jobfolder_path" in ip.user_ns,\ RuntimeError("Could not find path for current job-dictionary.") rootdir = dirname(ip.user_ns["current_jobfolder_path"]) # gets original lattice from job-dictionary. orig_structure = groundstate.jobparams["structure"] # Extracts computed lattice from ground state calculation. extract = groundstate.functional.Extract( join(rootdir, groundstate.name[1:]) ) assert extract.success, RuntimeError("Ground-state computation was not successful.") lattice = extract.structure.to_lattice() # creates superstructure. cell = dot(lattice.cell, input.supercell) result = fill_structure(cell, lattice) assert len(result.atoms) != len(lattice.sites), \ ValueError("Superstructure as large as lattice. Disable this line if that's ok.") # adds magnetic moment if necessary. if hasattr(orig_structure, "magmom"): assert extract.magnetization.shape[0] == len(lattice.sites),\ RuntimeError("Could not find magnetization in ground-state's OUTCAR.") mlat = lattice.deepcopy() for atom, m in zip(mlat.sites, extract.magnetization[:,-1]): if abs(m) < 0.1: atom.type = '0' elif m < 0e0: atom.type = str(int(m-1)) else: atom.type = str(int(m+1)) moments = fill_structure(cell, mlat) result.magmom = [ int(i.type) for i in moments.atoms ] return vasp_ordered(result, attributes=["magmom"]), lattice
from os.path import exists, join from math import ceil, sqrt from numpy import dot, array, matrix from numpy.linalg import norm from boost.mpi import world from pylada.vff import Vff from pylada.crystal import Structure, Lattice, fill_structure from pylada.escan import read_input input = read_input("input.py") structure = Structure() structure.set_cell = (4, 0, 0.5),\ (0, 1, 0),\ (0, 0, 0.5) structure = fill_structure(structure.cell) for i, atom in enumerate(structure.atoms): atom.type = "Si" if i < len(structure.atoms)/2 else "Ge" result_str = Structure() result_str.scale = 5.450000e+00 result_str.set_cell = (4.068890e+00, -4.235770e-18, 5.083297e-01),\ (-1.694308e-17, 1.016103e+00, 2.238072e-18),\ (-2.252168e-03, 8.711913e-18, 5.083297e-01) result_str.weight = 1.000000e+00 result_str.name = "" result_str.energy = 0.0938967086716 result_str.add_atom = (0.000000e+00, 0.000000e+00, 0.000000e+00), "Si", 0, 0 result_str.add_atom = (2.541649e-01, 2.473273e-01, 2.541649e-01), "Si", 1, 0 result_str.add_atom = (3.567265e+00, 5.062000e-01, -8.956567e-03), "Si", 0, 0
""" Point charge + r^12 + r^6 model. """ clj.ewald_cutoff = 80 * Ry clj.charges["A"] = -1.0 clj.charges["B"] = 1.0 structure = Structure() structure.set_cell = (1,0,0),\ (0,1,0),\ (0,0,1) structure.scale = 50 structure.add_atom = (0,0,0), "A" structure.add_atom = (a0.rescale(angstrom)/structure.scale,0,0), "B" print clj.ewald(structure).energy, hartree.rescale(eV) from pylada.crystal.A2BX4 import b5 from pylada.crystal import fill_structure from numpy import array clj.ewald_cutoff = 20 * Ry lattice = b5() lattice.sites[4].type='A' structure = fill_structure(lattice.cell, lattice) structure.scale = 8.0 clj.charges["A"] = 3.0 clj.charges["B"] = 2.0 clj.charges["X"] = -2.0 print clj.ewald(structure).energy, -498.586
from math import fabs as abs from numpy import array from pylada.crystal import fill_structure from pylada.escan import read_input from pylada.escan.emass import Functional input = read_input("input.py", namespace = {"Escan": Functional}) G = array([0,0,0], dtype="float64") X = array([0,0,1], dtype="float64") structure = fill_structure(input.vff.lattice.cell, input.vff.lattice) input.escan.nbstates = len(structure.atoms) * 4 + 4 input.escan.tolerance = 1e-12 orig = input.escan( structure, direction=(0,0,1), outdir="results/emass/100", \ do_relax_kpoint=False, type="e" ) assert abs(orig.mass[0] - 0.4381) < 0.01 # Gamma conduction emass result = input.escan( structure, direction=((0,0,1), (1,1,1)), outdir="results/hmass", \ do_relax_kpoint=False, type="h", bandgap=orig.extract_bg ) assert abs(result.mass[0][0] - 0.2769) < 0.01 # Gamma conduction heavy hmass (100 direction) assert abs(result.mass[0][2] - 0.2059) < 0.01 # Gamma conduction light hmass (100 direction) assert abs(result.mass[1][0] - 0.6885) < 0.01 # Gamma conduction heavy hmass (111 direction) assert abs(result.mass[1][2] - 0.1460) < 0.01 # Gamma conduction light hmass (111 direction)
from numpy import dot from pylada.crystal import fill_structure, FreezeAtom from pylada.vasp import read_input from pylada.vasp.emass import reciprocal from pylada.mpi import world input = read_input("input.py") structure = fill_structure(dot(input.lattice.cell, [[-1,0,0],[1,0,1],[1,1,0]]), input.lattice) for atom in structure.atoms: atom.freeze = FreezeAtom.x input.relaxer.vasp.launch_as_library = True input.relaxer.vasp.program = "vasp-4.6" input.relaxer.vasp.vasp_library = "libvasp-4.6.so" comm = world result = reciprocal(input.relaxer, structure, outdir="results", comm=comm)
def read_database(filename, withperms=True): from numpy import array as np_array, dot as np_dot, zeros as np_zeros from pylada import crystal, enumeration lattice = crystal.Lattice() with open(filename, "r") as file: # reads lattice for line in file: data = line.split() if len(data) == 0: continue if data[0] == "cell:": lattice.cell = np_array(data[1:], dtype="float64").reshape(3,3) elif data[0] == "scale:": lattice.scale = float(line.split()[1]) elif data[0] == "site:": data = line.split() data.pop(0) site = crystal.Site() for i in range(3): site.pos[i] = float(data.pop(0)) while len(data): site.type.append( data.pop(0) ) lattice.sites.append(site) elif data[0] == "endlattice": break lattice.set_as_crystal_lattice() transforms = enumeration.create_transforms(lattice) specialized = [] nsites = len([0 for i in lattice.sites if len(i.type) > 1]) hermite = None flavorbase = None transform = None structure = crystal.Structure() structure.scale = lattice.scale for line in file: data = line.split() if len(data) == 0: continue if data[0] == "n:": continue if data[0] == "hermite:": hermite = np_array(data[1:], dtype="float64").reshape(3,3) specialized = [] elif data[0] == "transform:": transform = np_array(data[1:], dtype="float64").reshape(3,3) elif data[0] == "smith:": smith = np_array( data[1:], dtype = "int64" ) translations = enumeration.Translation(smith, nsites) cell = np_dot(lattice.cell, hermite) structure = crystal.fill_structure(cell) for transformation in transforms: if not transformation.invariant(cell): continue transformation.init(transform, smith) if not transformation.is_trivial: specialized.append( transformation ) elif data[0] == "flavorbase:": card, nflavors = int(data[1]), int(data[2]) flavorbase = enumeration.create_flavorbase(card, nflavors) label_exchange=enumeration.LabelExchange(card, nflavors) elif len(data) > 0: assert flavorbase is not None assert hermite is not None for x in data: # adds label permutations that are not equivalent by affine transforms. x = int(x) others = set([x]) if withperms: for labelperm in label_exchange: u = labelperm(x, flavorbase) if u in others: continue dont = False for transform in specialized: t = transform(u, flavorbase) if t in others: dont = True break for translation in translations: v = translation(t, flavorbase) if v in others: dont = True break if not dont: others.add(u) for u in others: enumeration.as_structure(structure, u, flavorbase) yield structure
from pylada.escan._escan import to_realspace from pylada.escan._wfns import rtog_fourrier from pylada.vff import Vff from pylada.crystal import fill_structure, sort_layers, FreezeCell, nb_valence_states # reads input file. global_dict={"Vff": Vff, "Escan": Escan, "nb_valence_states": nb_valence_states, "soH": soH} input = read_input("input.py", global_dict=global_dict) # creating unrelaxed structure. input.vff.lattice.set_as_crystal_lattice() # cell = matrix([[0.5,-0.5,0],[0.5,0.5,0.5],[0,0,2.5]]) # structure = sort_layers(fill_structure(cell), array([0,0,2.5])) # for i, atom in enumerate(structure.atoms): # atom.type = "Si" if i % 10 < 6 else "Ge" structure = fill_structure(input.escan.vff.lattice.cell) structure.atoms[0].type = "Si" structure.scale = 5.55 structure.freeze = FreezeCell.a0 | FreezeCell.a1 input.escan.fft_mesh = 14, 14, 14 out = input.escan( structure,\ outdir=join("results", "wfns"),\ comm=world ) with Changedir(out.directory) as directory: nbstates = out.escan.nbstates if out.escan.potential == soH and norm(out.escan.kpoint)\ else out.escan.nbstates / 2 out.raw_gwfns out.escan._write_incar(out.comm, out.structure) with redirect(fout="") as streams: