def random_strain(mutant, debug=False): """ Apply random strain tensor to unit cell from 6 \\epsilon_i components with values between -1 and 1. The cell is then scaled to the parent's volume. Parameters: mutant (dict): structure to mutate in-place. """ def generate_cell_transform_matrix(): """ Pick a random transformation matrix. """ strain_components = 2 * np.random.rand(6) - 1 cell_transform_matrix = np.eye(3) for i in range(3): cell_transform_matrix[i][i] += strain_components[i] cell_transform_matrix[0][1] += strain_components[3] / 2 cell_transform_matrix[1][0] += strain_components[3] / 2 cell_transform_matrix[2][0] += strain_components[4] / 2 cell_transform_matrix[0][2] += strain_components[4] / 2 cell_transform_matrix[1][2] += strain_components[5] / 2 cell_transform_matrix[2][1] += strain_components[5] / 2 return cell_transform_matrix valid = False while not valid: cell_transform_matrix = generate_cell_transform_matrix() # only accept matrices with positive determinant, then scale that det to 1 if np.linalg.det(cell_transform_matrix) > 0: cell_transform_matrix /= pow(np.linalg.det(cell_transform_matrix), 1 / 3) valid = True if valid: # assert symmetry assert np.allclose(cell_transform_matrix.T, cell_transform_matrix) assert np.linalg.det(cell_transform_matrix) > 0 if debug: print(cell_transform_matrix) # exclude all strains that take us to sub-60 and sup-120 cell angles new_lattice_abc = cart2abc( np.matmul(cell_transform_matrix, np.array(mutant["lattice_cart"]))) for angle in new_lattice_abc[1]: if angle > 120 or angle < 60: valid = False # also exclude all cells where at least one lattice vector is less than 2 A mean_lat_vec = np.mean(new_lattice_abc[0]) for length in new_lattice_abc[0]: if length < mean_lat_vec / 2: valid = False mutant["lattice_cart"] = np.matmul(cell_transform_matrix, np.array( mutant["lattice_cart"])).tolist() mutant["lattice_abc"] = cart2abc(mutant["lattice_cart"]) if debug: print("lattice_abc:", mutant["lattice_abc"]) print("lattice_cart:", mutant["lattice_cart"]) print("cell_transform_matrix:", cell_transform_matrix.tolist())
def optimade_to_basic_cif(structure): """ A simple CIF creator that is enough to trick ChemDoodle. """ cif_string = "" lattice_abc = cart2abc(structure.attributes.lattice_vectors) positions_frac = cart2frac( structure.attributes.lattice_vectors, structure.attributes.cartesian_site_positions, ) cif_string += f"_cell_length_a {lattice_abc[0][0]}\n" cif_string += f"_cell_length_b {lattice_abc[0][1]}\n" cif_string += f"_cell_length_c {lattice_abc[0][2]}\n" cif_string += f"_cell_angle_alpha {lattice_abc[1][0]}\n" cif_string += f"_cell_angle_beta {lattice_abc[1][1]}\n" cif_string += f"_cell_angle_gamma {lattice_abc[1][2]}\n" cif_string += "loop_\n" cif_string += "_atom_site_label\n" cif_string += "_atom_site_symbol\n" cif_string += "_atom_site_fract_x\n" cif_string += "_atom_site_fract_y\n" cif_string += "_atom_site_fract_z\n" for atom, pos in zip(structure.attributes.species_at_sites, positions_frac): cif_string += f"{atom} {atom} {pos[0]} {pos[1]} {pos[2]}\n" return cif_string
def test_cart2abc(self): castep_fname = REAL_PATH + "data/Na3Zn4-swap-ReOs-OQMD_759599.castep" self.assertTrue(os.path.isfile(castep_fname)) test_doc, s = castep2dict(castep_fname, db=True, verbosity=VERBOSITY) try: self.assertTrue( np.allclose(test_doc["lattice_abc"], cart2abc(test_doc["lattice_cart"])), msg="Conversion cart2abc failed.", ) self.assertTrue( np.allclose( cart2abc(test_doc["lattice_cart"]), cart2abc(abc2cart(test_doc["lattice_abc"])), ), msg="Conversion abc2cart failed.", ) self.assertAlmostEqual( test_doc["cell_volume"], cart2volume(test_doc["lattice_cart"]), msg="Failed to calculate volume from lattice vectors.", places=5, ) self.assertIsInstance(test_doc["lattice_abc"], list, msg="Failed abc numpy cast to list") self.assertIsInstance( test_doc["lattice_cart"], list, msg="Failed cartesian numpy cast to list", ) cart_pos = frac2cart(test_doc["lattice_cart"], test_doc["positions_frac"]) back2frac = cart2frac(test_doc["lattice_cart"], cart_pos) np.testing.assert_array_almost_equal(back2frac, test_doc["positions_frac"]) except AssertionError: print("cart:", test_doc["lattice_cart"], abc2cart(test_doc["lattice_abc"])) print("abc:", test_doc["lattice_abc"], cart2abc(test_doc["lattice_cart"])) print( "volume:", test_doc["cell_volume"], cart2volume(test_doc["lattice_cart"]), ) raise AssertionError
def ase2dict(atoms, as_model=False) -> Union[dict, Crystal]: """ Return a matador document (dictionary or :obj:`Crystal`) from an `ase.Atoms` object. Parameters: atoms (ase.Atoms): input structure. Keyword arguments: as_model (bool): if `True`, return a Crystal instead of a dictionary. Returns: Union[dict, Crystal]: matador output. """ from matador.utils.cell_utils import cart2abc doc = {} # sort atoms, then their positions doc['atom_types'] = atoms.get_chemical_symbols() inds = [ i[0] for i in sorted(enumerate(doc['atom_types']), key=lambda x: x[1]) ] doc['positions_frac'] = atoms.get_scaled_positions().tolist() doc['positions_frac'] = [doc['positions_frac'][ind] for ind in inds] doc['atom_types'] = [doc['atom_types'][ind] for ind in inds] try: doc['lattice_cart'] = atoms.get_cell().tolist() except AttributeError: doc['lattice_cart'] = atoms.get_cell().array.tolist() doc['lattice_abc'] = cart2abc(doc['lattice_cart']) doc['num_atoms'] = len(doc['atom_types']) doc['stoichiometry'] = get_stoich(doc['atom_types']) doc['cell_volume'] = atoms.get_volume() doc['elems'] = {atom for atom in doc['atom_types']} doc['num_fu'] = doc['num_atoms'] / int( sum(doc['stoichiometry'][i][1] for i in range(len(doc['stoichiometry'])))) doc['space_group'] = get_spacegroup_spg(doc, symprec=0.001) if atoms.info: doc["ase_info"] = copy.deepcopy(atoms.info) if as_model: doc = Crystal(doc) return doc
def relax(self): from ase.optimize import LBFGS cached = sys.__stdout__ try: optimizer = LBFGS(self.ucf) optimizer.logfile = None optimised = optimizer.run(fmax=0.05, steps=100) except Exception: optimised = False self.doc["optimised"] = bool(optimised) self.doc["positions_abs"] = self.atoms.get_positions().tolist() self.doc["lattice_cart"] = self.atoms.get_cell().tolist() self.doc["lattice_abc"] = cart2abc(self.doc["lattice_cart"]) self.doc["positions_frac"] = cart2frac(self.doc["lattice_cart"], self.doc["positions_abs"]) self.doc["enthalpy_per_atom"] = float(self.calc.results["energy"] / len(self.doc["atom_types"])) self.doc["enthalpy"] = float(self.calc.results["energy"]) self.queue.put(self.doc) sys.stdout = cached
def doc2res(doc, path, overwrite=False, hash_dupe=False, info=True, spoof_titl=False, sort_atoms=True): """ Write .res file for single doc. Parameters: doc (dict): matador document containing structure path (str): desired filename for res file Keyword Arguments: info (bool): require info in res file header spoof_titl (bool): make up fake info for file header (for use with e.g. cryan) sorted (bool): if False, atoms are not sorted (this will not be a valid res file) overwrite (bool): whether or not to overwrite colliding files. hash_dupe (bool): whether or not to create a unique filename for any colliding files, or just skip writing them. """ if spoof_titl: info = False if not info: space_group = 'P1' if 'space_group' not in doc else doc['space_group'] if spoof_titl: titl = ('TITL {} -1 1 -1 0 0 {} ({}) n - 1').format( path.split('/')[-1], doc['num_atoms'], space_group) else: titl = ('TITL file generated by matador (Matthew Evans 2016)') else: try: titl = 'TITL ' titl += (path.split('/')[-1] + ' ') if 'pressure' not in doc or isinstance(doc['pressure'], str): titl += '0.00 ' else: titl += str(doc['pressure']) + ' ' if 'cell_volume' not in doc: titl += '0.0 ' else: titl += str(doc['cell_volume']) + ' ' if 'enthalpy' in doc and not isinstance(doc['enthalpy'], str): titl += str(doc['enthalpy']) + ' ' elif '0K_energy' in doc: titl += str(doc['0K_energy']) + ' ' elif 'total_energy' in doc: titl += str(doc['total_energy']) + ' ' else: raise KeyError('No energy field found.') titl += '0 0 ' # spin titl += str(doc['num_atoms']) + ' ' if 'space_group' not in doc: titl += '(P1) ' elif 'x' in doc['space_group']: titl += '(P1) ' else: titl += '(' + str(doc['space_group']) + ')' + ' ' titl += 'n - 1' except Exception: raise RuntimeError( 'Failed to get info for res file, turn info off.') if 'encapsulated' in doc and doc['encapsulated']: rem = ( "REM NTPROPS {{\'chiralN\': {}, \'chiralM\': {}, \'r\': {}, " "\'offset\': [0.5, 0.5, 0.5], \'date\': \'xxx\', \'eformperfu\': 12345, \'z\': {}}}" .format(doc['cnt_chiral'][0], doc['cnt_chiral'][1], doc['cnt_radius'], doc['cnt_length'])) flines = [] if 'encapsulated' in doc and doc['encapsulated']: flines.append(rem) flines.append(titl) cell_str = 'CELL 1.0 ' if ('lattice_abc' not in doc or len(doc['lattice_abc']) != 2 or len(doc['lattice_abc'][0]) != 3 or len(doc['lattice_abc'][1]) != 3): try: doc['lattice_abc'] = cart2abc(doc['lattice_cart']) except Exception: raise RuntimeError( 'Failed to get lattice, something has gone wrong for {}'. format(path)) for vec in doc['lattice_abc']: for coeff in vec: cell_str += ('{:.12f} '.format(coeff)) flines.append(cell_str) flines.append('LATT -1') # enforce correct order by elements, sorting only the atom_types, not the positions inside them if len(doc['positions_frac']) != len(doc['atom_types']): raise RuntimeError('Atom/position array mismatch!') if 'site_occupancy' in doc: if len(doc['site_occupancy']) != len(doc['positions_frac']): raise RuntimeError('Occupancy/position array mismatch!') if 'site_occupancy' not in doc: occupancies = [1.0] * len(doc['positions_frac']) if sort_atoms: positions_frac, atom_types = zip(*[(pos, types) for ( types, pos) in sorted(zip(doc['atom_types'], doc['positions_frac']), key=lambda k: k[0])]) if 'site_occupancy' in doc: occupancies, _atom_types = zip(*[(occ, types) for ( types, occ) in sorted(zip(doc['atom_types'], doc['site_occupancy']), key=lambda k: k[0])]) else: positions_frac = doc['positions_frac'] atom_types = doc['atom_types'] if len(positions_frac) != len( doc['positions_frac']) or len(atom_types) != len( doc['atom_types']): raise RuntimeError('Site occupancy mismatch!') written_atoms = [] sfac_str = 'SFAC \t' for elem in atom_types: if elem not in written_atoms: sfac_str += ' ' + str(elem) written_atoms.append(str(elem)) flines.append(sfac_str) atom_labels = [] i = 0 j = 1 while i < len(atom_types): num = atom_types.count(atom_types[i]) atom_labels.extend(num * [j]) i += num j += 1 for atom in zip(atom_types, atom_labels, positions_frac, occupancies): flines.append( "{0:8s}{1:3d}{2[0]: 20.15f} {2[1]: 20.15f} {2[2]: 20.15f} {3: 20.15f}" .format(atom[0], atom[1], atom[2], atom[3])) flines.append('END') # very important newline for compatibliy with cryan # flines.append('') return flines, 'res'
def pwout2dict(fname, **kwargs): """ Extract available information from pw.x .out file. Parameters: fname (str/list): filename or list of filenames to scrape as a QuantumEspresso pw.x output. """ flines, fname = get_flines_extension_agnostic(fname, ["out", "in"]) pwout = {} pwout['source'] = [fname] try: # grab file owner username from pwd import getpwuid pwout['user'] = getpwuid(stat(fname).st_uid).pw_name except Exception: pwout['user'] = '******' if 'CollCode' in fname: pwout['icsd'] = fname.split('CollCode')[-1] for ind, line in enumerate(reversed(flines)): ind = len(flines) - 1 - ind if 'cell_parameters' in line.lower() and 'angstrom' in line.lower( ) and 'lattice_cart' not in pwout: pwout['lattice_cart'] = [] for j in range(3): line = flines[ind + j + 1].strip().split() pwout['lattice_cart'].append(list(map(float, line))) pwout['cell_volume'] = cart2volume(pwout['lattice_cart']) elif 'atomic_positions' in line.lower( ) and 'positions_frac' not in pwout: pwout['positions_frac'] = [] pwout['atom_types'] = [] j = 1 while True: if 'End final coordinates' in flines[j + ind]: break else: try: line = flines[j + ind].strip().split() pwout['atom_types'].append(line[0]) pwout['positions_frac'].append( list(map(float, line[1:5]))) j += 1 except Exception: break pwout['num_atoms'] = len(pwout['atom_types']) elif 'final enthalpy' in line.lower() and 'enthalpy' not in pwout: pwout['enthalpy'] = RY_TO_EV * float(line.lower().split()[-2]) elif 'total stress' in line.lower() and 'pressure' not in pwout: pwout['pressure'] = KBAR_TO_GPA * float(line.lower().split()[-1]) elif all(key in pwout for key in ['enthalpy', 'pressure', 'lattice_cart', 'positions_frac']): break # get abc lattice pwout['lattice_abc'] = cart2abc(pwout['lattice_cart']) # calculate stoichiometry pwout['stoichiometry'] = defaultdict(float) for atom in pwout['atom_types']: if atom not in pwout['stoichiometry']: pwout['stoichiometry'][atom] = 0 pwout['stoichiometry'][atom] += 1 gcd_val = 0 for atom in pwout['atom_types']: if gcd_val == 0: gcd_val = pwout['stoichiometry'][atom] else: gcd_val = gcd(pwout['stoichiometry'][atom], gcd_val) # convert stoichiometry to tuple for fryan temp_stoich = [] for key, value in pwout['stoichiometry'].items(): if float(value) / gcd_val % 1 != 0: temp_stoich.append([key, float(value) / gcd_val]) else: temp_stoich.append([key, value / gcd_val]) pwout['stoichiometry'] = temp_stoich atoms_per_fu = 0 for elem in pwout['stoichiometry']: atoms_per_fu += elem[1] pwout['num_fu'] = len(pwout['atom_types']) / atoms_per_fu return pwout, True
def random_slice(parent_seeds, standardize=True, supercell=True, shift=True, debug=False): """ Simple cut-and-splice crossover of two parents. The overall size of the child can vary between 0.5 and 1.5 the size of the parent structures. Both parent structures are cut and spliced along the same crystallographic axis. Parameters: parents (list(dict)) : parent structures to crossover, standardize (bool) : use spglib to standardize parents pre-crossover, supercell (bool) : make a random supercell to rescale parents, shift (bool) : randomly shift atoms in parents to unbias. Returns: dict: newborn structure from parents. """ parents = deepcopy(parent_seeds) child = dict() # child_size is a number between 0.5 and 2 child_size = 0.5 + 1.5 * np.random.rand() # cut_val is a number between 0.25*child_size and 0.75*child_size # the slice position of one parent in fractional coordinates # (the other is (child_size-cut_val)) cut_val = child_size * (0.25 + (np.random.rand() / 2.0)) parent_densities = [] for ind, parent in enumerate(parents): if "cell_volume" not in parent: parents[ind]["cell_volume"] = cart2volume(parent["lattice_cart"]) parent_densities.append(parent["num_atoms"] / parent["cell_volume"]) target_density = sum(parent_densities) / len(parent_densities) if standardize: parents = [standardize_doc_cell(parent) for parent in parents] if supercell: # check ratio of num atoms in parents and grow the smaller one parent_extent_ratio = parents[0]["cell_volume"] / parents[1][ "cell_volume"] if debug: print( parent_extent_ratio, parents[0]["cell_volume"], "vs", parents[1]["cell_volume"], ) if parent_extent_ratio < 1: supercell_factor = int(round(1 / parent_extent_ratio)) supercell_target = 0 elif parent_extent_ratio >= 1: supercell_factor = int(round(parent_extent_ratio)) supercell_target = 1 if debug: print(supercell_target, supercell_factor) supercell_vector = [1, 1, 1] if supercell_factor > 1: for ind in range(supercell_factor): min_lat_vec_abs = 1e10 min_lat_vec_ind = -1 for i in range(3): lat_vec_abs = np.sum( np.asarray( parents[supercell_target]["lattice_cart"][i])**2) if lat_vec_abs < min_lat_vec_abs: min_lat_vec_abs = lat_vec_abs min_lat_vec_ind = i supercell_vector[min_lat_vec_ind] += 1 if debug: print("Making supercell of {} with {}".format( parents[supercell_target]["source"][0], supercell_vector)) if supercell_vector != [1, 1, 1]: parents[supercell_target] = create_simple_supercell( parents[supercell_target], supercell_vector, standardize=False) child["positions_frac"] = [] child["atom_types"] = [] child["lattice_cart"] = cut_val * np.asarray( parents[0]["lattice_cart"]) + (child_size - cut_val) * np.asarray( parents[1]["lattice_cart"]) child["lattice_cart"] = child["lattice_cart"].tolist() # choose slice axis axis = np.random.randint(low=0, high=3) for ind, parent in enumerate(parents): if shift: # apply same random shift to all atoms in parents shift_vec = np.random.rand(3) for idx, _ in enumerate(parent["positions_frac"]): for k in range(3): parent["positions_frac"][idx][k] += shift_vec[k] if parent["positions_frac"][idx][k] >= 1: parent["positions_frac"][idx][k] -= 1 elif parent["positions_frac"][idx][k] < 0: parent["positions_frac"][idx][k] += 1 # slice parent for atom, pos in zip(parent["atom_types"], parent["positions_frac"]): if ind == (pos[axis] <= cut_val): child["positions_frac"].append(pos) child["atom_types"].append(atom) # check child is sensible child["mutations"] = ["crossover"] child["stoichiometry"] = get_stoich(child["atom_types"]) child["num_atoms"] = len(child["atom_types"]) if "cell_volume" not in child: child["cell_volume"] = cart2volume(child["lattice_cart"]) number_density = child["num_atoms"] / child["cell_volume"] # rescale cell based on number density of parents new_scale = np.cbrt(number_density / target_density) child["lattice_abc"] = np.asarray(cart2abc(child["lattice_cart"])) child["lattice_abc"][0] *= new_scale child["lattice_abc"] = child["lattice_abc"].tolist() child["lattice_cart"] = abc2cart(child["lattice_abc"]) child["cell_volume"] = cart2volume(child["lattice_cart"]) child["positions_abs"] = frac2cart(child["lattice_cart"], child["positions_frac"]) return child
def check_feasible(mutant, parents, max_num_atoms, structure_filter=None, minsep_dict=None, debug=False): """ Check if a mutated/newly-born cell is "feasible". Here, feasible means: * number density within 25% of pre-mutation/birth level, * no overlapping atoms, parameterised by minsep_dict, * cell angles between 50 and 130 degrees, * fewer than max_num_atoms in the cell, * ensure number of atomic types is maintained, * any custom filter is obeyed. Parameters: mutant (dict): matador doc containing new structure. parents (list(dict)): list of doc(s) containing parent structures. max_num_atoms (int): any structures with more than this many atoms will be filtered out. Keyword Arguments: structure_filter (callable): any function that takes a matador document and returns True or False. minsep_dict (dict): dictionary containing element-specific minimum separations, e.g. {('K', 'K'): 2.5, ('K', 'P'): 2.0}. Returns: bool: True if structure is feasible, else False. """ # first check the structure filter if structure_filter is not None and not structure_filter(mutant): message = "Mutant with {} failed to pass the custom filter.".format( ", ".join(mutant["mutations"])) LOG.debug(message) if debug: print(message) return False # check number of atoms if "num_atoms" not in mutant or mutant["num_atoms"] != len( mutant["atom_types"]): mutant["num_atoms"] = len(mutant["atom_types"]) if mutant["num_atoms"] > max_num_atoms: message = "Mutant with {} contained too many atoms ({} vs {}).".format( ", ".join(mutant["mutations"]), mutant["num_atoms"], max_num_atoms) LOG.debug(message) if debug: print(message) return False # check number density if "cell_volume" not in mutant: mutant["cell_volume"] = cart2volume(mutant["lattice_cart"]) number_density = mutant["num_atoms"] / mutant["cell_volume"] parent_densities = [] for ind, parent in enumerate(parents): if "cell_volume" not in parent: parents[ind]["cell_volume"] = cart2volume(parent["lattice_cart"]) parent_densities.append(parent["num_atoms"] / parent["cell_volume"]) target_density = sum(parent_densities) / len(parent_densities) if number_density > 1.5 * target_density or number_density < 0.5 * target_density: message = "Mutant with {} failed number density.".format(", ".join( mutant["mutations"])) LOG.debug(message) if debug: print(message) return False # now check element-agnostic minseps if not minseps_feasible(mutant, minsep_dict=minsep_dict, debug=debug): return False # check all cell angles are between 60 and 120. if "lattice_abc" not in mutant: mutant["lattice_abc"] = cart2abc(mutant["lattice_cart"]) if min(mutant["lattice_abc"][1]) < 30: message = "Mutant with {} failed cell angle check.".format(", ".join( mutant["mutations"])) LOG.debug(message) if debug: print(message) return False if max(mutant["lattice_abc"][1]) > 120: message = "Mutant with {} failed cell angle check.".format(", ".join( mutant["mutations"])) LOG.debug(message) if debug: print(message) return False # check that we haven't deleted/transmuted all atoms of a certain type if len(set(mutant["atom_types"])) < len(set(parents[0]["atom_types"])): message = "Mutant with {} transmutation error.".format(", ".join( mutant["mutations"])) LOG.debug(message) if debug: print(message) return False return True
def magres2dict(fname, **kwargs): """ Extract available information from .magres file. Assumes units of Angstrom and ppm for relevant quantities. """ magres = defaultdict(list) flines, fname = get_flines_extension_agnostic(fname, "magres") magres['source'] = [fname] # grab file owner username try: from pwd import getpwuid magres['user'] = getpwuid(stat(fname).st_uid).pw_name except Exception: magres['user'] = '******' magres['magres_units'] = dict() for line_no, line in enumerate(flines): line = line.lower().strip() if line in ['<atoms>', '[atoms]']: i = 1 while flines[line_no + i].strip().lower() not in ['</atoms>', '[/atoms]']: split_line = flines[line_no + i].split() if not split_line: i += 1 continue if i > len(flines): raise RuntimeError("Something went wrong in reader loop") if split_line[0] == 'units': magres['magres_units'][split_line[1]] = split_line[2] elif 'lattice' in split_line: lattice = split_line[1:] for j in range(3): magres['lattice_cart'].append([ float(elem) for elem in lattice[j * 3:(j + 1) * 3] ]) magres['lattice_abc'] = cart2abc(magres['lattice_cart']) elif 'atom' in split_line: atom = split_line magres['atom_types'].append(atom[1]) magres['positions_abs'].append( [float(elem) for elem in atom[-3:]]) i += 1 break if "atom_types" in magres: magres['num_atoms'] = len(magres['atom_types']) magres['positions_frac'] = cart2frac(magres['lattice_cart'], magres['positions_abs']) magres['stoichiometry'] = get_stoich(magres['atom_types']) for line_no, line in enumerate(flines): line = line.lower().strip() if line in ['<magres>', '[magres]']: i = 1 while flines[line_no + i].strip().lower() not in ['</magres>', '[/magres]']: split_line = flines[line_no + i].split() if not split_line: i += 1 continue if i > len(flines): raise RuntimeError("Something went wrong in reader loop") if split_line[0] == 'units': magres['magres_units'][split_line[1]] = split_line[2] elif 'sus' in split_line: magres["susceptibility_tensor"] = np.array( [float(val) for val in split_line[1:]]).reshape(3, 3) elif 'ms' in split_line: ms = np.array([float(val) for val in split_line[3:]]).reshape(3, 3) s_iso = np.trace(ms) / 3 # find eigenvalues of symmetric part of shielding and order them to calc anisotropy eta symmetric_shielding = _symmetrise_tensor(ms) s_yy, s_xx, s_zz = _get_haeberlen_eigs(symmetric_shielding) s_aniso = s_zz - (s_xx + s_yy) / 2.0 asymm = (s_yy - s_xx) / (s_zz - s_iso) # convert from reduced anistropy to CSA magres["magnetic_shielding_tensors"].append(ms) magres["chemical_shielding_isos"].append(s_iso) magres["chemical_shift_anisos"].append(s_aniso) magres["chemical_shift_asymmetries"].append(asymm) elif "efg" in split_line: efg = np.array([float(val) for val in split_line[3:]]).reshape(3, 3) species = split_line[1] eigs = _get_haeberlen_eigs(efg) v_zz, eta = eigs[2], (eigs[0] - eigs[1]) / eigs[2] # calculate C_Q in MHz quadrupole_moment = ELECTRIC_QUADRUPOLE_MOMENTS.get( species, 1.0) C_Q = ((ELECTRON_CHARGE * v_zz * quadrupole_moment * EFG_AU_TO_SI * BARN_TO_M2) / (PLANCK_CONSTANT * 1e6)) magres["electric_field_gradient"].append(efg) magres["quadrupolar_couplings"].append(C_Q) magres["quadrupolar_asymmetries"].append(eta) i += 1 for line_no, line in enumerate(flines): line = line.lower().strip() if line in ['<calculation>', '[calculation]']: i = 1 while flines[line_no + i].strip().lower() not in [ '</calculation>', '[/calculation]' ]: if i > len(flines): raise RuntimeError("Something went wrong in reader loop") # space important as it excludes other calc_code_x variables if 'calc_code ' in flines[line_no + i]: magres['calculator'] = flines[line_no + i].split()[1] if 'calc_code_version' in flines[line_no + i]: magres['calculator_version'] = flines[line_no + i].split()[1] i += 1 return dict(magres), True
def lattice_cart(self, new_lattice): self._lattice_cart = tuple(tuple(vec) for vec in new_lattice) self._lattice_abc = tuple( tuple(elem) for elem in cell_utils.cart2abc(self._lattice_cart)) self._volume = None
def magres2dict(fname, **kwargs): """ Extract available information from .magres file. Assumes units of Angstrom and ppm for relevant quantities. """ magres = defaultdict(list) flines, fname = get_flines_extension_agnostic(fname, "magres") magres['source'] = [fname] # grab file owner username try: magres['user'] = getpwuid(stat(fname).st_uid).pw_name except Exception: magres['user'] = '******' magres['magres_units'] = dict() for line_no, line in enumerate(flines): line = line.lower().strip() if line in ['<atoms>', '[atoms]']: i = 1 while flines[line_no + i].strip().lower() not in ['</atoms>', '[/atoms]']: split_line = flines[line_no + i].split() if not split_line: i += 1 continue if i > len(flines): raise RuntimeError("Something went wrong in reader loop") if split_line[0] == 'units': magres['magres_units'][split_line[1]] = split_line[2] elif 'lattice' in flines[line_no + i]: lattice = flines[line_no + i].split()[1:] for j in range(3): magres['lattice_cart'].append([ float(elem) for elem in lattice[j * 3:(j + 1) * 3] ]) magres['lattice_abc'] = cart2abc(magres['lattice_cart']) elif 'atom' in flines[line_no + i]: atom = flines[line_no + i].split() magres['atom_types'].append(atom[1]) magres['positions_abs'].append( [float(elem) for elem in atom[-3:]]) i += 1 break magres['num_atoms'] = len(magres['atom_types']) magres['positions_frac'] = cart2frac(magres['lattice_cart'], magres['positions_abs']) magres['stoichiometry'] = get_stoich(magres['atom_types']) for line_no, line in enumerate(flines): line = line.lower().strip() if line in ['<magres>', '[magres]']: i = 1 while flines[line_no + i].strip().lower() not in ['</magres>', '[/magres]']: split_line = flines[line_no + i].split() if not split_line: i += 1 continue if i > len(flines): raise RuntimeError("Something went wrong in reader loop") if split_line[0] == 'units': magres['magres_units'][split_line[1]] = split_line[2] elif 'sus' in flines[line_no + i]: sus = flines[line_no + i].split()[1:] for j in range(3): magres['susceptibility_tensor'].append( [float(val) for val in sus[3 * j:3 * (j + 1)]]) elif 'ms' in flines[line_no + i]: ms = flines[line_no + i].split()[3:] magres['magnetic_shielding_tensors'].append([]) for j in range(3): magres['magnetic_shielding_tensors'][-1].append( [float(val) for val in ms[3 * j:3 * (j + 1)]]) magres['chemical_shielding_isos'].append(0) magres['chemical_shift_anisos'].append(0) magres['chemical_shift_asymmetries'].append(0) for j in range(3): magres['chemical_shielding_isos'][-1] += magres[ 'magnetic_shielding_tensors'][-1][j][j] / 3 # find eigenvalues of symmetric part of shielding and order them to calc anisotropy eta symmetric_shielding = ( 0.5 * (magres['magnetic_shielding_tensors'][-1] + np.asarray( magres['magnetic_shielding_tensors'][-1]).T)) eig_vals, eig_vecs = np.linalg.eig(symmetric_shielding) eig_vals, eig_vecs = zip( *sorted(zip(eig_vals, eig_vecs), key=lambda eig: abs(eig[0] - magres[ 'chemical_shielding_isos'][-1]))) # Haeberlen convention: |s_zz - s_iso| >= |s_xx - s_iso| >= |s_yy - s_iso| s_yy, s_xx, s_zz = eig_vals s_iso = magres['chemical_shielding_isos'][-1] # convert from reduced anistropy to CSA magres['chemical_shift_anisos'][-1] = s_zz - (s_xx + s_yy) / 2.0 magres['chemical_shift_asymmetries'][-1] = ( s_yy - s_xx) / (s_zz - s_iso) i += 1 for line_no, line in enumerate(flines): line = line.lower().strip() if line in ['<calculation>', '[calculation]']: i = 1 while flines[line_no + i].strip().lower() not in [ '</calculation>', '[/calculation]' ]: if i > len(flines): raise RuntimeError("Something went wrong in reader loop") # space important as it excludes other calc_code_x variables if 'calc_code ' in flines[line_no + i]: magres['calculator'] = flines[line_no + i].split()[1] if 'calc_code_version' in flines[line_no + i]: magres['calculator_version'] = flines[line_no + i].split()[1] i += 1 return magres, True
def preprocess(self): """ Decide which parts of the Workflow need to be performed, and set the appropriate CASTEP parameters. """ # default todo todo = { 'relax': True, 'dynmat': True, 'vdos': False, 'dispersion': False, 'thermodynamics': False } # definition of steps and names steps = { 'relax': castep_phonon_prerelax, 'dynmat': castep_phonon_dynmat, 'vdos': castep_phonon_dos, 'dispersion': castep_phonon_dispersion, 'thermodynamics': castep_phonon_thermodynamics } exts = { 'relax': { 'input': ['.cell', '.param'], 'output': ['.castep', '-out.cell', '.*err'] }, 'dynmat': { 'input': ['.cell', '.param'], 'output': ['.castep', '.*err'] }, 'vdos': { 'input': ['.cell', '.param'], 'output': ['.castep', '.phonon', '.phonon_dos', '.*err'] }, 'dispersion': { 'input': ['.cell', '.param'], 'output': ['.castep', '.phonon', '.*err'] }, 'thermodynamics': { 'input': ['.cell', '.param'], 'output': ['.castep', '.*err'] } } if self.calc_doc.get('task').lower() in [ 'phonon', 'thermodynamics', 'phonon+efield' ]: if ('phonon_fine_kpoint_path' in self.calc_doc or 'phonon_fine_kpoint_list' in self.calc_doc or 'phonon_fine_kpoint_path_spacing' in self.calc_doc): todo['dispersion'] = True if 'phonon_fine_kpoint_mp_spacing' in self.calc_doc: todo['vdos'] = True if self.calc_doc['task'].lower() == 'thermodynamics': todo['thermodynamics'] = True # prepare to do pre-relax if there's no check file if os.path.isfile(self.seed + '.check'): todo['relax'] = False LOG.info( 'Restarting from {}.check, so not performing re-relaxation'. format(self.seed)) for key in todo: if todo[key]: self.add_step(steps[key], key, input_exts=exts[key].get('input'), output_exts=exts[key].get('output')) # always standardise the cell so that any phonon calculation can have # post-processing performed after the fact, unless a path has been provided if 'phonon_fine_kpoint_list' not in self.calc_doc and 'phonon_fine_kpoint_path' not in self.calc_doc: from matador.utils.cell_utils import cart2abc prim_doc, kpt_path = self.computer.get_seekpath_compliant_input( self.calc_doc, self.calc_doc.get('phonon_fine_kpoint_path_spacing', 0.02)) self.calc_doc.update(prim_doc) self.calc_doc['lattice_abc'] = cart2abc( self.calc_doc['lattice_cart']) if todo['dispersion']: self.calc_doc['phonon_fine_kpoint_list'] = kpt_path elif todo['dispersion'] and 'phonon_fine_kpoint_path' in self.calc_doc: self._user_defined_kpt_path = True LOG.warning('Using user-defined k-point path for all structures.') self.calc_doc['phonon_fine_kpoint_spacing'] = self.calc_doc.get( 'phonon_fine_kpoint_path_spacing', 0.05) # always shift phonon grid to include Gamma if 'phonon_kpoint_mp_spacing' in self.calc_doc: from matador.utils.cell_utils import calc_mp_grid, shift_to_include_gamma grid = calc_mp_grid(self.calc_doc['lattice_cart'], self.calc_doc['phonon_kpoint_mp_spacing']) offset = shift_to_include_gamma(grid) if offset != [0, 0, 0]: self.calc_doc['phonon_kpoint_mp_offset'] = offset LOG.debug('Set phonon MP grid offset to {}'.format(offset)) LOG.info( 'Preprocessing completed: run3 phonon options {}'.format(todo))
def preprocess(self): """ Decide which parts of the Workflow need to be performed, and set the appropriate CASTEP parameters. """ # default todo todo = { 'scf': True, 'dos': False, 'pdos': False, 'broadening': False, 'dispersion': False, 'pdis': False } # definition of steps and names steps = { 'scf': castep_spectral_scf, 'dos': castep_spectral_dos, 'pdos': optados_pdos, 'broadening': optados_dos_broadening, 'dispersion': castep_spectral_dispersion, 'pdis': optados_pdispersion } exts = { 'scf': { 'input': ['.cell', '.param'], 'output': ['.castep', '.*err', '-out.cell'] }, 'dos': { 'input': ['.cell', '.param'], 'output': [ '.castep', '.bands', '.pdos_bin', '.dome_bin', '.*err', '-out.cell' ] }, 'dispersion': { 'input': ['.cell', '.param'], 'output': [ '.castep', '.bands', '.pdos_bin', '.dome_bin', '.*err', '-out.cell' ] }, 'pdis': { 'input': ['.odi', '.pdos_bin'], 'output': ['.odo', '.*err'] }, 'pdos': { 'input': ['.odi', '.pdos_bin', '.dome_bin'], 'output': ['.odo', '.*err'] }, 'broadening': { 'input': ['.odi', '.pdos_bin', '.dome_bin'], 'output': ['.odo', '.*err'] } } if os.path.isfile(self.seed + '.check'): LOG.info('Found {}.check, so skipping initial SCF.'.format( self.seed)) todo['scf'] = False if (('spectral_kpoints_path' in self.calc_doc or 'spectral_kpoints_list' in self.calc_doc or 'spectral_kpoints_path_spacing' in self.calc_doc or self.calc_doc.get('spectral_task', '').lower() == 'bandstructure')): todo['dispersion'] = not os.path.isfile(self.seed + '.bands_dispersion') if ('spectral_kpoints_mp_spacing' in self.calc_doc or self.calc_doc.get('spectral_task', '').lower() == 'dos'): todo['dos'] = not os.path.isfile(self.seed + '.bands_dos') odi_fname = _get_optados_fname(self.seed) if odi_fname is not None: odi_dict, _ = arbitrary2dict(odi_fname) if todo['dispersion']: todo['pdis'] = 'pdispersion' in odi_dict if todo['dos']: todo['broadening'] = 'broadening' in odi_dict todo['pdos'] = 'pdos' in odi_dict for key in todo: if todo[key]: self.add_step(steps[key], key, input_exts=exts[key].get('input'), output_exts=exts[key].get('output')) if self.computer.run3_settings.get('run3_settings') is not None: settings = self.computer.kwargs.get('run3_settings') # check that computer.exec was not overriden at cmd-line, then check settings file if settings.get( 'castep_executable' ) is not None and self.computer.executable == 'castep': self.castep_executable = settings.get('castep_executable', 'castep') self.computer.executable = self.castep_executable if settings.get('optados_executable') is not None: self.optados_executable = settings.get('optados_executable', 'optados') self.computer.optados_executable = self.optados_executable # if not using a user-requested path, use seekpath and spglib # to reduce to primitive and use consistent path if 'spectral_kpoints_list' not in self.calc_doc and 'spectral_kpoints_path' not in self.calc_doc: from matador.utils.cell_utils import cart2abc prim_doc, kpt_path = self.computer.get_seekpath_compliant_input( self.calc_doc, self.calc_doc.get('spectral_kpoints_path_spacing', 0.05)) self.calc_doc.update(prim_doc) self.calc_doc['lattice_abc'] = cart2abc( self.calc_doc['lattice_cart']) if todo['dispersion']: self.calc_doc['spectral_kpoints_list'] = kpt_path elif todo['dispersion'] and 'spectral_kpoints_path' in self.calc_doc: self._user_defined_kpt_path = True LOG.warning('Using user-defined k-point path for all structures.') self.calc_doc['spectral_kpoints_path_spacing'] = self.calc_doc.get( 'spectral_kpoints_path_spacing', 0.05) if todo['dos']: self.calc_doc['spectral_kpoints_mp_spacing'] = self.calc_doc.get( 'spectral_kpoints_mp_spacing', 0.05) # always use continuation self.calc_doc['continuation'] = 'default' LOG.info( 'Preprocessing completed: run3 spectral options {}'.format(todo))