def iterate(self, method="hessian", supercell=None, q=None, nrattle=0): """Returns a list of possible configurations, one for each eigenmode in the system, that has `supercell` is compatible with the specified `q` vector. Args: method (str): desired method for computing the eigenvalues and eigenvectors. Possible choices are :meth:`hessian` or :meth:`dynmat`. supercell (numpy.ndarray): supercell matrix to use in generating the configs. q (numpy.ndarray): q-vector that the resulting supercell should be compatible with. nrattle (int): number of additional, empty configs to include via :meth:`quippy.Atoms.rattle`. """ if method == "hessian": dmd = self.hessian() elif method == "vasp_hessian": dmd = self.vasp_hessian() else: dmd = self.dynmat(supercell, q) hname = "hessian1" seed = quippy.Atoms() seed.copy_from(dmd["template"]) result = quippy.AtomsList() result.append(dmd["template"]) #Delete the force, energy and virial information from the copy, so that #we don't duplicate it all over. del seed.params["dft_energy"] del seed.params["dft_virial"] del seed.properties["dft_force"] for l, v in zip(dmd["eigvals"], dmd["eigvecs"]): atc = seed.copy() #Add this eigenvector to its own configuration. atc.add_property(hname, 0.0, n_cols=3) H = np.reshape(v.real, (atc.n, 3)).T setattr(atc, hname, H) #Same thing for the eigenvalue. Then save it to the group folder #structure. atc.params.set_value(hname, l) atc.params.set_value("n_hessian", 1) #atc.add_property("force", 0.0, n_cols=3) result.append(atc) for i in range(nrattle): atRand = seed.copy() quippy.randomise(atRand.pos, 0.2) result.append(atRand) # atz = seed.copy() # atz.add_property("dft_force", 0.0, n_cols=3) #atz.params.set_value("dft_energy", return result
def get_raw_soap_wrapper(kwargs): fpointer = kwargs.pop('fpointer') # need to copy the frame to avoid seg fault in quip if rerun the procedure on the same name space frame = qp.Atoms(fpointer=fpointer).copy() kwargs.update({'atoms': frame, 'spkit': get_spkit(frame)}) idx = kwargs.pop('idx') return (idx, get_soap(**kwargs))
def __init__(self, sn, tracer_atomic_number=None, soap_params={}, verbose=True): # Make a copy of the structure self._structure = qp.Atoms(sn.static_structure) # Add a tracer if tracer_atomic_number is None: tracer_atomic_number = sn.structure.get_atomic_numbers()[ sn.mobile_mask][0] self.tracer_atomic_number = tracer_atomic_number self._structure.add_atoms((0.0, 0.0, 0.0), tracer_atomic_number) self._tracer_index = len(self._structure) - 1 # Create the descriptor soap_opts = dict(DEFAULT_SOAP_PARAMS) soap_opts.update(soap_params) soap_cmd_line = ["soap"] # User options for opt in soap_opts: soap_cmd_line.append("{}={}".format(opt, soap_opts[opt])) # Stuff that's the same no matter what soap_cmd_line.append("n_Z=1") #always one tracer soap_cmd_line.append("Z={{{}}}".format(self.tracer_atomic_number)) self._soaper = descriptors.Descriptor(" ".join(soap_cmd_line)) self.verbose = verbose
def setUp(self): self.dia_quippy = diamond(5.44, 14) self.dia_quippy.add_property( 'magmoms', np.random.uniform(-1, 1, size=3 * 8).reshape(3, 8)) self.dia_quippy.add_property('charge', [1.0] * 8) self.dia_ase = ase.Atoms(self.dia_quippy) self.dia_quippy_2 = quippy.Atoms(self.dia_ase)
def framesprod_wrapper(kargs): keys = kargs.keys() get_envKernel = kargs.pop('frameprodFunc') queue = kargs.pop('queue') # to disable the progressbar dispbar = kargs.pop('dispbar') if 'fpointers1' in keys: fpointers1 = kargs.pop('fpointers1') fpointers2 = kargs.pop('fpointers2') atoms1 = [qp.Atoms(fpointer=fpointer1) for fpointer1 in fpointers1] chemicalKernelmat = kargs.pop('chemicalKernelmat') frames1 = get_Soaps(atoms1, dispbar=dispbar, **kargs) if fpointers2 is not None: atoms2 = [qp.Atoms(fpointer=fpointer2) for fpointer2 in fpointers2] frames2 = get_Soaps(atoms2, dispbar=dispbar, **kargs) else: frames2 = None kargs = { 'frames1': frames1, 'frames2': frames2, 'chemicalKernelmat': chemicalKernelmat } elif 'atoms1' in keys: atoms1 = kargs.pop('atoms1') atoms2 = kargs.pop('atoms2') chemicalKernelmat = kargs.pop('chemicalKernelmat') frames1 = get_Soaps(atoms1, dispbar=dispbar, **kargs) if atoms2 is not None: frames2 = get_Soaps(atoms2, dispbar=dispbar, **kargs) else: frames2 = None kargs = { 'frames1': frames1, 'frames2': frames2, 'chemicalKernelmat': chemicalKernelmat } return framesprod(queue=queue, frameprodFunc=get_envKernel, **kargs)
def __init__(self, filepath): self.filepath = filepath self.atoms = quippy.Atoms(filepath) self.xyz = self.atoms.positions self.extras = list(self.atoms.properties.keys()) for k in self.extras: setattr(self, k, self.atoms.properties[k]) self.types = None self.box = self.atoms.lattice
def enthalpy(sqnc, p=None): """Returns Helmholtz enthalpy, h=E+PV per atom of the polytype stack sequence Args: sqnc (string): polytype stacking sequence For example, 'abc' or 'abcabcacbacb'. p (float): hydrostatic pressure in epsilon per sigma cubed units; default None. Returns: float """ apos = aparray(sqnc) N = len(apos) lat = [[1., 0., 0.], [0.5, sqrt(3) / 2., 0.], [0., 0., N * sqrt(2. / 3)]] numbers = [] for i in range(0, N): numbers.append(14) plyt = quippy.Atoms(n=N, lattice=lat, positions=apos, numbers=numbers) plyt.set_cutoff(LJ.cutoff()) plyt.calc_connect() LJ.calc(plyt, energy=True) e1 = plyt.energy v = plyt.get_volume() print("Initial energy: ", e1) print("Initial volume: ", v) plyt.calc_connect() pressure = [[p, 0., 0.], [0., p, 0.], [0., 0., p]] LJ.minim(plyt, 'cg', 1e-12, 100, do_pos=True, do_lat=True, external_pressure=pressure) LJ.calc(plyt, energy=True) e2 = plyt.energy v = plyt.get_volume() print("Energy for {} after relaxing: ".format(sqnc), e2) print("Volume after relaxing: ", v, " per ", N, " atoms.") #plyt.write("{}.xyz".format(sqnc)) if p == None: p = 0 h = (e2 + p * v) / N #hd=(hf-h)/N return h
def get_alchemy_frame( spkit, spkitMax,atoms=None,fpointer=None, nocenters=None, centerweight=1., gaussian_width=0.5,cutoff=3.5, chemicalProjection=None, cutoff_transition_width=0.5, nmax=8, lmax=6,chem_channels=True,is_fast_average=False,queue=None): if nocenters is None: nocenters = [] if atoms is None and fpointer is not None: atoms = qp.Atoms(fpointer=fpointer) elif atoms is not None and fpointer is None: atoms = atoms elif atoms is not None and fpointer is not None: atoms = atoms else: raise NotImplementedError('At least atoms or fpointer needs to be given') spkit = get_spkit(atoms) soapParams = {'spkit': spkit, 'spkitMax': spkitMax, 'nocenters': nocenters, 'centerweight': centerweight, 'gaussian_width': gaussian_width, 'cutoff': cutoff, 'cutoff_transition_width': cutoff_transition_width, 'nmax': nmax, 'lmax': lmax,'is_fast_average':is_fast_average} rawsoaps = get_soap(atoms, **soapParams) zList = atoms.get_atomic_numbers() mm = envIdx2centerIdxMap(atoms, spkit, nocenters) # chemical channel separation for each central atom species # and each atomic environment alchemyFrame = AlchemyFrame(atom=atoms, nocenters=nocenters, soapParams=soapParams,is_fast_average=is_fast_average) Nenv, Npowerspectrum = rawsoaps.shape if chem_channels: for it in range(Nenv): # soap[it] is (1,Npowerspectrum) so need to transpose it # convert the soap vector of an environment from quippy descriptor to soap vectors # with chemical channels. alchemySoapdict = Soap2AlchemySoap(rawsoaps[it, :], spkitMax, nmax, lmax) alchemySoap = AlchemySoap(qpatoms=atoms, soapParams=soapParams, centerIdx=mm[it], is_fast_average=is_fast_average) alchemySoap.from_dict(alchemySoapdict) if chemicalProjection is not None: alchemySoap = ProjectedAlchemySoap(alchemySoap,chemicalProjection) centerZ = zList[mm[it]] if not is_fast_average else 'AVG' alchemyFrame[centerZ] = alchemySoap else: for it in xrange(Nenv): centerZ = zList[mm[it]] if not is_fast_average else 'AVG' alchemyFrame[centerZ] = rawsoaps[it, :] return alchemyFrame
def create_hcp_custom(c_vs_a, V_per_at, z): import quippy import numpy as np V = 2.0 * V_per_at a = (2 * V / (3.0**(0.5) * c_vs_a))**(1.0 / 3.0) c = c_vs_a * a lattice = [] lattice.append([3.0**(0.5) / 2.0 * a, -a / 2.0, 0]) lattice.append([3.0**(0.5) / 2.0 * a, a / 2.0, 0]) lattice.append([0, 0, c]) lattice = np.transpose(lattice) unitcell = quippy.Atoms(n=0, lattice=lattice) pos = [] pos.append([3.0**(0.5) / 6.0 * a, 0, 0.0]) pos.append([3.0**(0.5) / 2.0 * a, 0, c / 2.0]) for i in range(0, len(pos)): unitcell.add_atoms(pos[i], z) return unitcell
def __init__(self, init_file, args_str, param_file, latency=1.0e-3, name="", pars=None, dopbc=True, threaded=False): """Initialises QUIP. Args: pars: Mandatory dictionary, giving the parameters needed by QUIP. """ if quippy is None: info("QUIPPY import failed", verbosity.low) raise quippy_exc # a socket to the communication library is created or linked super(FFQUIP, self).__init__(latency, name, pars, dopbc, threaded=threaded) self.init_file = init_file self.args_str = args_str self.param_file = param_file # Initializes an atoms object and the interaction potential self.atoms = quippy.Atoms(self.init_file) self.pot = quippy.Potential(self.args_str, param_filename=self.param_file) # Initializes the conversion factors from i-pi to QUIP self.len_conv = unit_to_user("length", "angstrom", 1) self.energy_conv = unit_to_user("energy", "electronvolt", 1) self.force_conv = unit_to_user("force", "ev/ang", 1)
def __init__(self, primitive, supercell, folder, vasp=False): self.atoms = PhonopyAtoms(symbols=primitive.get_chemical_symbols(), positions=primitive.positions, masses=primitive.get_masses(), cell=primitive.cell, pbc=primitive.pbc) self.supercell = supercell self.folder = folder if not vasp: self.phonopy = Phonopy(self.atoms, supercell) self._get_dynmatrix() self.primitive = self.phonopy._dynamical_matrix.get_primitive() else: from matdb.io import vasp_to_xyz self.phonopy = Phonopy(self.atoms, supercell) if path.isfile("FORCE_CONSTANTS"): fc = file_IO.parse_FORCE_CONSTANTS(filename="FORCE_CONSTANTS") self.phonopy.set_force_constants(fc) self.phonopy._set_dynamical_matrix() self.primitive = primitive vasp_to_xyz(folder) self.parent = quippy.Atoms(path.join(folder, "output.xyz"))
str(lat_vec_mean_histo[i]) + "\n") V_aver_per_at = V / len(at) at_name_average_list = [] # list of atom objects and their names for struc in ref_struc_name_list: at_name_average_list.append([ misc_calc_lib.create_at_accord_struc(V_aver_per_at, z_ref, struc), struc ]) for path in ref_struc_config_path_list: at_old = quippy.Atoms(path) # load in the reference structure V_old_per_at = at_old.get_volume() / len(at_old) f = V_aver_per_at / V_old_per_at # stretch/shrink factor for volume (need third root of this for each dimension) # Creating a new atoms object with the appropriate volume at_new = quippy.Atoms(n=len(at_old)) at_new.set_cell(at_old.get_cell() * f**(1.0 / 3.0)) at_new.set_positions(at_old.get_positions() * f**(1.0 / 3.0)) at_new.set_atomic_numbers(at_old.get_atomic_numbers()) at_name_average_list.append( [at_new, misc_calc_lib.raw_filename_xyz_extxyz(path)]) for el in at_name_average_list:
# the script that actually computes SOAP. Called by `quippy_interface.py`. import os print( "This is the output of the run_quippy.py script. Printing the environment variables for easier debugging." ) print(os.environ) import quippy import ase import numpy as np with open("quippy_config.txt", "r") as f: config = f.read() all_ase = ase.io.iread("data.traj") descs = [] cutoffs = [] for at_ase in all_ase: at = quippy.Atoms(at_ase) desc = quippy.descriptors.Descriptor(config) at.set_cutoff(desc.cutoff()) at.calc_connect() desc_out = desc.calc(at) descs.append(np.round(desc_out["descriptor"], 20)) cutoffs.append(desc_out["cutoff"]) np.save("out", descs) # automatically saves as dtype=object
def setUp(self): self.dia_quippy = diamond(5.44, 14) self.dia_quippy.add_property('new', -1.0) self.dia_ase = ase.Atoms(self.dia_quippy) self.dia_quippy_2 = quippy.Atoms(self.dia_ase)
def setUp(self): self.dia_quippy = diamond(5.44, 14) self.dia_ase = ase.Atoms(self.dia_quippy) self.dia_quippy_2 = quippy.Atoms(self.dia_ase)
import os.path, ase.io from utilities import relax_config, run_root import random import quippy test_dir = os.path.abspath(os.path.dirname(__file__)) bulk = ase.io.read(os.path.join(test_dir,"bulk.xyz"), format="extxyz") tol=1.0e-3 # hack to work around bad convergence relaxed_bulk = relax_config(bulk, relax_pos=True, relax_cell=True, tol=tol, traj_file=None, config_label='bulk', from_base_model=True, save_config=True) relaxed_bulk_pe = relaxed_bulk.get_potential_energy()/len(bulk) orig_cell = relaxed_bulk.get_cell() energies = [] ns=20 for i in range(0,ns+1): l_factor = 1.0-0.5*float(i)/float(ns) relaxed_bulk.set_cell(orig_cell*l_factor, True) qrb = quippy.Atoms(relaxed_bulk) qrb.set_cutoff(3.0) qrb.calc_connect() try: energies.append([ min([nn.distance for nn in qrb.neighbours[1]]), relaxed_bulk.get_potential_energy()/len(relaxed_bulk) ]) except: break properties={ 'unrelaxed_energies' : energies }
if vacuum is not None: shrink_cell(atoms) atoms.cell += np.eye(3) * vacuum axis_mask = [True if ax in axis else False for ax in range(3)] atoms.positions -= atoms.positions.mean(axis=0) * axis_mask return calc = quippy.Potential('IP TS', param_filename="ts_params.xml") # Load atomic configuration fld = sys.argv[1].strip() params.os.chdir(fld) crack_slab = quippy.Atoms('slab.xyz') print('Unit slab with %d atoms per unit cell:' % len(crack_slab)) print(crack_slab.cell) print('') in_put = raw_input('Perform dry system generation (guess configuration)?') GUESS_RUN = (in_put in ['y', 'Y', 'yes']) if GUESS_RUN: print("Performing dry run...") else: print("Performing full system construction...") # open up the cell along x and y by introducing some vacuum center_atoms(crack_slab, vacuum=params.vacuum) # centre the slab on the origin
jjj += 1 traj_name = 'md-%s-%03d.xyz' % (basename, jjj) db_name = 'db-%s-%03d.csv' % (basename, jjj) log_name = 'md-%s-%03d.log' % (basename, jjj) # ***** Initialise Atoms object ***** if not at.has_property('momenta'): print("Resetting momenta to desired temperature") MaxwellBoltzmannDistribution(at, 2.0 * params.sim_T * units.kB) try: clamp_mask = at.get_array('clamp_mask') fix_line_mask = at.get_array('fix_line_mask') initial_positions = at.get_array('pos_orig') except: at_help = quippy.Atoms('crack.xyz') clamp_mask = at_help.get_array('clamp_mask') # fix_line_mask = at_help.get_array('fix_line_mask') initial_positions = at_help.get_array('pos_orig') at_help = None at.set_calculator(calc) # set atoms order _, dists = find_mic(initial_positions - initial_positions[tipatoms[0]], at.get_cell()) at_order = np.argsort(dists)[:120] # ***** Setup constraints ***** # springs = [Hookean(a1=i, a2=[0,-1,0,initial_positions[i,1]], k=k_spring, rt=0) for i in np.where(clamp_mask)[0]] springs = [
import quippy import re import os import __builtin__ # the current model import model a0 = 5.43 # initial guess at lattice constant, cell will be relaxed below N = 2 # number of unit cells in each direction # set up the a bulk = Diamond(symbol='Si', latticeconstant=a0) bulk *= (N, N, N) bulk = quippy.Atoms(bulk) def save_hook(traj, a=bulk): traj.append(a.copy()) quippy.system_set_random_seeds(10) debug = True save_traj = True n_steps_heat = 20000 n_steps_equil = 10000 n_steps_liquid = 5000 T_melt = 5000.0 T_equil = 2000.0