def to_singlepointkpts(self): kpts = [] for i, (index, spins) in enumerate(self.data.items()): weight = self.weights[index] for spin, (_, data) in enumerate(spins.items()): energies, occs = np.array(sorted(data, key=lambda x: x[0])).T kpts.append(SinglePointKPoint(weight, spin, i, energies, occs)) return kpts
def test_dos(): from ase.atoms import Atoms from ase.calculators.singlepoint import SinglePointDFTCalculator from ase.calculators.singlepoint import SinglePointKPoint from ase.dft.dos import DOS atoms = Atoms('H') eFermi = [0, 1] kpts = [SinglePointKPoint(1, 0, 0), SinglePointKPoint(1, 1, 0)] kpts[0].eps_n = [-2, -1, 1] kpts[0].f_n = [1, 0, 0] kpts[1].eps_n = [-2.5, -1.5, 0.5] kpts[1].f_n = [1, 0, 0] calc = SinglePointDFTCalculator(atoms, efermi=eFermi) calc.kpts = kpts DOS(calc)
def _get_gto_evals(chunk): spin = 1 if re.match(r'[ \t\S]+Beta', chunk) else 0 data = [] for vector in _extract_vector.finditer(chunk): data.append([float(x.replace('D', 'E')) for x in vector.groups()[1:]]) data = np.array(data) occ = data[:, 0] energies = data[:, 1] * Hartree return SinglePointKPoint(1., spin, 0, energies, occ)
def read_old_gpw(filename): from gpaw.io.tar import Reader r = Reader(filename) positions = r.get('CartesianPositions') * Bohr numbers = r.get('AtomicNumbers') cell = r.get('UnitCell') * Bohr pbc = r.get('BoundaryConditions') tags = r.get('Tags') magmoms = r.get('MagneticMoments') energy = r.get('PotentialEnergy') * Hartree if r.has_array('CartesianForces'): forces = r.get('CartesianForces') * Hartree / Bohr else: forces = None atoms = Atoms(positions=positions, numbers=numbers, cell=cell, pbc=pbc) if tags.any(): atoms.set_tags(tags) if magmoms.any(): atoms.set_initial_magnetic_moments(magmoms) magmom = magmoms.sum() else: magmoms = None magmom = None atoms.calc = SinglePointDFTCalculator(atoms, energy=energy, forces=forces, magmoms=magmoms, magmom=magmom) kpts = [] if r.has_array('IBZKPoints'): for w, kpt, eps_n, f_n in zip(r.get('IBZKPointWeights'), r.get('IBZKPoints'), r.get('Eigenvalues'), r.get('OccupationNumbers')): kpts.append(SinglePointKPoint(w, kpt[0], kpt[1], eps_n[0], f_n[0])) atoms.calc.kpts = kpts return atoms
def read_gpw(filename): try: reader = ulm.open(filename) except ulm.InvalidULMFileError: return read_old_gpw(filename) atoms = read_atoms(reader.atoms, _try_except=False) wfs = reader.wave_functions kpts = wfs.get('kpts') if kpts is None: ibzkpts = None bzkpts = None bz2ibz = None else: ibzkpts = kpts.ibzkpts bzkpts = kpts.get('bzkpts') bz2ibz = kpts.get('bz2ibz') if reader.version >= 3: efermi = reader.wave_functions.fermi_levels.mean() else: efermi = reader.occupations.fermilevel atoms.calc = SinglePointDFTCalculator(atoms, efermi=efermi, ibzkpts=ibzkpts, bzkpts=bzkpts, bz2ibz=bz2ibz, **reader.results.asdict()) if kpts is not None: atoms.calc.kpts = [] spin = 0 for eps_kn, f_kn in zip(wfs.eigenvalues, wfs.occupations): kpt = 0 for weight, eps_n, f_n in zip(kpts.weights, eps_kn, f_kn): atoms.calc.kpts.append( SinglePointKPoint(weight, spin, kpt, eps_n, f_n)) kpt += 1 spin += 1 return atoms
def parse(self, cursor: _CURSOR, lines: _CHUNK) -> _RESULT: nkpts = self.get_from_header('nkpts') nbands = self.get_from_header('nbands') weights = self.get_from_header('kpt_weights') spinpol = self.get_from_header('spinpol') nspins = 2 if spinpol else 1 kpts = [] for spin in range(nspins): # The cursor should be on a "spin componenet" line now assert 'spin component' in lines[cursor] cursor += 2 # Skip two lines for _ in range(nkpts): line = self.get_line(cursor, lines) # Example line: # "k-point 1 : 0.0000 0.0000 0.0000" parts = line.strip().split() ikpt = int(parts[1]) - 1 # Make kpt idx start from 0 weight = weights[ikpt] cursor += 2 # Move down two eigenvalues = np.zeros(nbands) occupations = np.zeros(nbands) for n in range(nbands): # Example line: # " 1 -9.9948 1.00000" parts = lines[cursor].strip().split() eps_n, f_n = map(float, parts[1:]) occupations[n] = f_n eigenvalues[n] = eps_n cursor += 1 kpt = SinglePointKPoint(weight, spin, ikpt, eps_n=eigenvalues, f_n=occupations) kpts.append(kpt) cursor += 1 # shift by 1 more at the end, prepare for next k-point return {'kpts': kpts}
def read(filename, index=None, format=None): """Read Atoms object(s) from file. filename: str Name of the file to read from. index: int or slice If the file contains several configurations, the last configuration will be returned by default. Use index=n to get configuration number n (counting from zero). format: str Used to specify the file-format. If not given, the file-format will be guessed by the *filetype* function. Known formats: ========================= ============= format short name ========================= ============= GPAW restart-file gpw Dacapo netCDF output file dacapo Old ASE netCDF trajectory nc Virtual Nano Lab file vnl ASE pickle trajectory traj ASE bundle trajectory bundle GPAW text output gpaw-text CUBE file cube XCrySDen Structure File xsf Dacapo text output dacapo-text XYZ-file xyz VASP POSCAR/CONTCAR file vasp VASP OUTCAR file vasp_out SIESTA STRUCT file struct_out ABINIT input file abinit V_Sim ascii file v_sim Protein Data Bank pdb CIF-file cif FHI-aims geometry file aims FHI-aims output file aims_out VTK XML Image Data vti VTK XML Structured Grid vts VTK XML Unstructured Grid vtu TURBOMOLE coord file tmol TURBOMOLE gradient file tmol-gradient exciting input exi AtomEye configuration cfg WIEN2k structure file struct DftbPlus input file dftb CASTEP geom file cell CASTEP output file castep CASTEP trajectory file geom ETSF format etsf.nc DFTBPlus GEN format gen CMR db/cmr-file db CMR db/cmr-file cmr LAMMPS dump file lammps EON reactant.con file eon Gromacs coordinates gro Gaussian com (input) file gaussian Gaussian output file gaussian_out Quantum espresso in file esp_in Quantum espresso out file esp_out Extended XYZ file extxyz NWChem input file nw ========================= ============= """ if isinstance(filename, str) and ('.json@' in filename or '.db@' in filename or filename.startswith('pg://') and '@' in filename): filename, index = filename.rsplit('@', 1) if index.isdigit(): index = int(index) else: if isinstance(filename, str): p = filename.rfind('@') if p != -1: try: index = string2index(filename[p + 1:]) except ValueError: pass else: filename = filename[:p] if isinstance(index, str): index = string2index(index) if format is None: format = filetype(filename) if format.startswith('gpw'): import gpaw r = gpaw.io.open(filename, 'r') positions = r.get('CartesianPositions') * Bohr numbers = r.get('AtomicNumbers') cell = r.get('UnitCell') * Bohr pbc = r.get('BoundaryConditions') tags = r.get('Tags') magmoms = r.get('MagneticMoments') energy = r.get('PotentialEnergy') * Hartree if r.has_array('CartesianForces'): forces = r.get('CartesianForces') * Hartree / Bohr else: forces = None atoms = Atoms(positions=positions, numbers=numbers, cell=cell, pbc=pbc) if tags.any(): atoms.set_tags(tags) if magmoms.any(): atoms.set_initial_magnetic_moments(magmoms) else: magmoms = None atoms.calc = SinglePointDFTCalculator(atoms, energy=energy, forces=forces, magmoms=magmoms) kpts = [] if r.has_array('IBZKPoints'): for w, kpt, eps_n, f_n in zip(r.get('IBZKPointWeights'), r.get('IBZKPoints'), r.get('Eigenvalues'), r.get('OccupationNumbers')): kpts.append( SinglePointKPoint(w, kpt[0], kpt[1], eps_n[0], f_n[0])) atoms.calc.kpts = kpts return atoms if format in ['json', 'db', 'postgresql']: from ase.db.core import connect, dict2atoms if index == slice(None, None): index = None images = [ dict2atoms(d) for d in connect(filename, format).select(index) ] if len(images) == 1: return images[0] else: return images if index is None: index = -1 if format == 'castep': from ase.io.castep import read_castep return read_castep(filename, index) if format == 'castep_cell': import ase.io.castep return ase.io.castep.read_cell(filename, index) if format == 'castep_geom': import ase.io.castep return ase.io.castep.read_geom(filename, index) if format == 'exi': from ase.io.exciting import read_exciting return read_exciting(filename, index) if format in ['xyz', 'extxyz']: from ase.io.extxyz import read_xyz return read_xyz(filename, index) if format == 'traj': from ase.io.trajectory import read_trajectory return read_trajectory(filename, index) if format == 'bundle': from ase.io.bundletrajectory import read_bundletrajectory return read_bundletrajectory(filename, index) if format == 'cube': from ase.io.cube import read_cube return read_cube(filename, index) if format == 'nc': from ase.io.netcdf import read_netcdf return read_netcdf(filename, index) if format == 'gpaw-text': from ase.io.gpawtext import read_gpaw_text return read_gpaw_text(filename, index) if format == 'dacapo-text': from ase.io.dacapo import read_dacapo_text return read_dacapo_text(filename) if format == 'dacapo': from ase.io.dacapo import read_dacapo return read_dacapo(filename) if format == 'xsf': from ase.io.xsf import read_xsf return read_xsf(filename, index) if format == 'vasp': from ase.io.vasp import read_vasp return read_vasp(filename) if format == 'vasp_out': from ase.io.vasp import read_vasp_out return read_vasp_out(filename, index) if format == 'abinit': from ase.io.abinit import read_abinit return read_abinit(filename) if format == 'v_sim': from ase.io.v_sim import read_v_sim return read_v_sim(filename) if format == 'mol': from ase.io.mol import read_mol return read_mol(filename) if format == 'pdb': from ase.io.pdb import read_pdb return read_pdb(filename, index) if format == 'cif': from ase.io.cif import read_cif return read_cif(filename, index) if format == 'struct': from ase.io.wien2k import read_struct return read_struct(filename) if format == 'struct_out': from ase.io.siesta import read_struct return read_struct(filename) if format == 'vti': from ase.io.vtkxml import read_vti return read_vti(filename) if format == 'vts': from ase.io.vtkxml import read_vts return read_vts(filename) if format == 'vtu': from ase.io.vtkxml import read_vtu return read_vtu(filename) if format == 'aims': from ase.io.aims import read_aims return read_aims(filename) if format == 'aims_out': from ase.io.aims import read_aims_output return read_aims_output(filename, index) if format == 'iwm': from ase.io.iwm import read_iwm return read_iwm(filename) if format == 'Cmdft': from ase.io.cmdft import read_I_info return read_I_info(filename) if format == 'tmol': from ase.io.turbomole import read_turbomole return read_turbomole(filename) if format == 'tmol-gradient': from ase.io.turbomole import read_turbomole_gradient return read_turbomole_gradient(filename) if format == 'cfg': from ase.io.cfg import read_cfg return read_cfg(filename) if format == 'dftb': from ase.io.dftb import read_dftb return read_dftb(filename) if format == 'sdf': from ase.io.sdf import read_sdf return read_sdf(filename) if format == 'etsf': from ase.io.etsf import ETSFReader return ETSFReader(filename).read_atoms() if format == 'gen': from ase.io.gen import read_gen return read_gen(filename) if format == 'cmr': from ase.io.cmr_io import read_db return read_db(filename, index) if format == 'lammps': from ase.io.lammpsrun import read_lammps_dump return read_lammps_dump(filename, index) if format == 'eon': from ase.io.eon import read_reactant_con return read_reactant_con(filename) if format == 'gromacs': from ase.io.gromacs import read_gromacs return read_gromacs(filename) if format == 'gaussian': from ase.io.gaussian import read_gaussian return read_gaussian(filename) if format == 'gaussian_out': from ase.io.gaussian import read_gaussian_out return read_gaussian_out(filename, index) if format == 'esp_in': from ase.io.espresso import read_espresso_in return read_espresso_in(filename) if format == 'esp_out': from ase.io.espresso import read_espresso_out return read_espresso_out(filename, index) if format == 'nw': from ase.io.nwchem import read_nwchem_input return read_nwchem_input(filename) raise RuntimeError('File format descriptor ' + format + ' not recognized!')
def read_gpaw_out(fileobj, index): notfound = [] def index_startswith(lines, string): if not isinstance(string, str): # assume it's a list for entry in string: try: return index_startswith(lines, entry) except ValueError: pass raise ValueError if string in notfound: raise ValueError for i, line in enumerate(lines): if line.startswith(string): return i notfound.append(string) raise ValueError def index_pattern(lines, pattern): repat = re.compile(pattern) if pattern in notfound: raise ValueError for i, line in enumerate(lines): if repat.match(line): return i notfound.append(pattern) raise ValueError def read_forces(lines, ii): f = [] for i in range(ii + 1, ii + 1 + len(atoms)): try: x, y, z = lines[i].split()[-3:] f.append((float(x), float(y), float(z))) except (ValueError, IndexError) as m: raise IOError('Malformed GPAW log file: %s' % m) return f, i lines = [line.lower() for line in fileobj.readlines()] images = [] while True: try: i = index_startswith(lines, 'reference energy:') Eref = float(lines[i].split()[-1]) except ValueError: Eref = None try: i = lines.index('unit cell:\n') except ValueError: pass else: if lines[i + 2].startswith(' -'): del lines[i + 2] # old format cell = [] pbc = [] for line in lines[i + 2:i + 5]: words = line.split() if len(words) == 5: # old format cell.append(float(words[2])) pbc.append(words[1] == 'yes') else: # new format with GUC cell.append([float(word) for word in words[3:6]]) pbc.append(words[2] == 'yes') try: i = lines.index('positions:\n') except ValueError: break symbols = [] positions = [] for line in lines[i + 1:]: words = line.split() if len(words) < 5: break n, symbol, x, y, z = words[:5] symbols.append(symbol.split('.')[0].title()) positions.append([float(x), float(y), float(z)]) if len(symbols): atoms = Atoms(symbols=symbols, positions=positions, cell=cell, pbc=pbc) else: atoms = Atoms(cell=cell, pbc=pbc) lines = lines[i + 5:] try: ii = index_pattern(lines, '\\d+ k-point') word = lines[ii].split() kx = int(word[2]) ky = int(word[4]) kz = int(word[6]) bz_kpts = (kx, ky, kz) ibz_kpts = int(lines[ii + 1].split()[0]) except (ValueError, TypeError, IndexError): bz_kpts = None ibz_kpts = None try: i = index_startswith(lines, 'energy contributions relative to') except ValueError: e = energy_contributions = None else: energy_contributions = {} for line in lines[i + 2:i + 8]: fields = line.split(':') energy_contributions[fields[0]] = float(fields[1]) line = lines[i + 10] assert (line.startswith('zero kelvin:') or line.startswith('extrapolated:')) e = float(line.split()[-1]) try: ii = index_pattern(lines, '(fixed )?fermi level(s)?:') except ValueError: eFermi = None else: fields = lines[ii].split() try: def strip(string): for rubbish in '[],': string = string.replace(rubbish, '') return string eFermi = [float(strip(fields[-2])), float(strip(fields[-1]))] except ValueError: eFermi = float(fields[-1]) # read Eigenvalues and occupations ii1 = ii2 = 1e32 try: ii1 = index_startswith(lines, ' band eigenvalues occupancy') except ValueError: pass try: ii2 = index_startswith(lines, ' band eigenvalues occupancy') except ValueError: pass ii = min(ii1, ii2) if ii == 1e32: kpts = None else: ii += 1 words = lines[ii].split() vals = [] while (len(words) > 2): vals.append([float(w) for w in words]) ii += 1 words = lines[ii].split() vals = np.array(vals).transpose() kpts = [SinglePointKPoint(1, 0, 0)] kpts[0].eps_n = vals[1] kpts[0].f_n = vals[2] if vals.shape[0] > 3: kpts.append(SinglePointKPoint(1, 1, 0)) kpts[1].eps_n = vals[3] kpts[1].f_n = vals[4] # read charge try: ii = index_startswith(lines, 'total charge:') except ValueError: q = None else: q = float(lines[ii].split()[2]) # read dipole moment try: ii = index_startswith(lines, 'dipole moment:') except ValueError: dipole = None else: line = lines[ii] for x in '()[],': line = line.replace(x, '') dipole = np.array([float(c) for c in line.split()[2:5]]) try: ii = index_startswith(lines, 'local magnetic moments') except ValueError: magmoms = None else: magmoms = [] for j in range(ii + 1, ii + 1 + len(atoms)): magmom = lines[j].split()[-1].rstrip(')') magmoms.append(float(magmom)) try: ii = lines.index('forces in ev/ang:\n') except ValueError: f = None else: f, i = read_forces(lines, ii) try: ii = index_startswith(lines, 'vdw correction:') except ValueError: pass else: line = lines[ii + 1] assert line.startswith('energy:') e = float(line.split()[-1]) f, i = read_forces(lines, ii + 3) if len(images) > 0 and e is None: break if q is not None and len(atoms) > 0: n = len(atoms) atoms.set_initial_charges([q / n] * n) if magmoms is not None: atoms.set_initial_magnetic_moments(magmoms) if e is not None or f is not None: calc = SinglePointDFTCalculator(atoms, energy=e, forces=f, dipole=dipole, magmoms=magmoms, efermi=eFermi, bzkpts=bz_kpts, ibzkpts=ibz_kpts) calc.eref = Eref calc.name = 'gpaw' if energy_contributions is not None: calc.energy_contributions = energy_contributions if kpts is not None: calc.kpts = kpts atoms.calc = calc images.append(atoms) lines = lines[i:] if len(images) == 0: raise IOError('Corrupted GPAW-text file!') return images[index]
def read_gpaw_out(fileobj, index): # -> Union[Atoms, List[Atoms]]: """Read text output from GPAW calculation.""" lines = [line.lower() for line in fileobj.readlines()] blocks = [] i1 = 0 for i2, line in enumerate(lines): if line == 'positions:\n': if i1 > 0: blocks.append(lines[i1:i2]) i1 = i2 blocks.append(lines[i1:]) images: List[Atoms] = [] for lines in blocks: try: i = lines.index('unit cell:\n') except ValueError: pass else: if lines[i + 2].startswith(' -'): del lines[i + 2] # old format cell: List[Union[float, List[float]]] = [] pbc = [] for line in lines[i + 2:i + 5]: words = line.split() if len(words) == 5: # old format cell.append(float(words[2])) pbc.append(words[1] == 'yes') else: # new format with GUC cell.append([float(word) for word in words[3:6]]) pbc.append(words[2] == 'yes') symbols = [] positions = [] magmoms = [] for line in lines[1:]: words = line.split() if len(words) < 5: break n, symbol, x, y, z = words[:5] symbols.append(symbol.split('.')[0].title()) positions.append([float(x), float(y), float(z)]) if len(words) > 5: mom = float(words[-1].rstrip(')')) magmoms.append(mom) if len(symbols): atoms = Atoms(symbols=symbols, positions=positions, cell=cell, pbc=pbc) else: atoms = Atoms(cell=cell, pbc=pbc) try: ii = index_pattern(lines, '\\d+ k-point') word = lines[ii].split() kx = int(word[2]) ky = int(word[4]) kz = int(word[6]) bz_kpts = (kx, ky, kz) ibz_kpts = int(lines[ii + 1].split()[0]) except (ValueError, TypeError, IndexError): bz_kpts = None ibz_kpts = None try: i = index_startswith(lines, 'energy contributions relative to') except ValueError: e = energy_contributions = None else: energy_contributions = {} for line in lines[i + 2:i + 8]: fields = line.split(':') energy_contributions[fields[0]] = float(fields[1]) line = lines[i + 10] assert (line.startswith('zero kelvin:') or line.startswith('extrapolated:')) e = float(line.split()[-1]) try: ii = index_pattern(lines, '(fixed )?fermi level(s)?:') except ValueError: eFermi = None else: fields = lines[ii].split() try: def strip(string): for rubbish in '[],': string = string.replace(rubbish, '') return string eFermi = [float(strip(fields[-2])), float(strip(fields[-1]))] except ValueError: eFermi = float(fields[-1]) # read Eigenvalues and occupations ii1 = ii2 = 1e32 try: ii1 = index_startswith(lines, ' band eigenvalues occupancy') except ValueError: pass try: ii2 = index_startswith(lines, ' band eigenvalues occupancy') except ValueError: pass ii = min(ii1, ii2) if ii == 1e32: kpts = None else: ii += 1 words = lines[ii].split() vals = [] while(len(words) > 2): vals.append([float(w) for w in words]) ii += 1 words = lines[ii].split() vals = np.array(vals).transpose() kpts = [SinglePointKPoint(1, 0, 0)] kpts[0].eps_n = vals[1] kpts[0].f_n = vals[2] if vals.shape[0] > 3: kpts.append(SinglePointKPoint(1, 1, 0)) kpts[1].eps_n = vals[3] kpts[1].f_n = vals[4] # read charge try: ii = index_startswith(lines, 'total charge:') except ValueError: q = None else: q = float(lines[ii].split()[2]) # read dipole moment try: ii = index_startswith(lines, 'dipole moment:') except ValueError: dipole = None else: line = lines[ii] for x in '()[],': line = line.replace(x, '') dipole = np.array([float(c) for c in line.split()[2:5]]) try: ii = index_startswith(lines, 'local magnetic moments') except ValueError: pass else: magmoms = [] for j in range(ii + 1, ii + 1 + len(atoms)): magmom = lines[j].split()[-1].rstrip(')') magmoms.append(float(magmom)) try: ii = lines.index('forces in ev/ang:\n') except ValueError: f = None else: f, i = read_forces(lines, ii, atoms) try: parameters = {} ii = index_startswith(lines, 'vdw correction:') except ValueError: name = 'gpaw' else: name = lines[ii - 1].strip() # save uncorrected values parameters.update({ 'calculator': 'gpaw', 'uncorrected_energy': e, }) line = lines[ii + 1] assert line.startswith('energy:') e = float(line.split()[-1]) f, i = read_forces(lines, ii + 3, atoms) if len(images) > 0 and e is None: break if q is not None and len(atoms) > 0: n = len(atoms) atoms.set_initial_charges([q / n] * n) if magmoms: atoms.set_initial_magnetic_moments(magmoms) else: magmoms = None if e is not None or f is not None: calc = SinglePointDFTCalculator(atoms, energy=e, forces=f, dipole=dipole, magmoms=magmoms, efermi=eFermi, bzkpts=bz_kpts, ibzkpts=ibz_kpts) calc.name = name calc.parameters = parameters if energy_contributions is not None: calc.energy_contributions = energy_contributions if kpts is not None: calc.kpts = kpts atoms.calc = calc images.append(atoms) if len(images) == 0: raise IOError('Corrupted GPAW-text file!') return images[index]
def read_vasp_xml(filename='vasprun.xml', index=-1): """Parse vasprun.xml file. Reads unit cell, atom positions, energies, forces, and constraints from vasprun.xml file """ import numpy as np import xml.etree.ElementTree as ET from ase import Atoms from ase.constraints import FixAtoms, FixScaled from ase.calculators.singlepoint import (SinglePointDFTCalculator, SinglePointKPoint) from ase.units import GPa from collections import OrderedDict tree = ET.iterparse(filename, events=['start', 'end']) atoms_init = None calculation = [] ibz_kpts = None kpt_weights = None parameters = OrderedDict() try: for event, elem in tree: if event == 'end': if elem.tag == 'kpoints': for subelem in elem.iter(tag='generation'): kpts_params = OrderedDict() parameters['kpoints_generation'] = kpts_params for par in subelem.iter(): if par.tag in ['v', 'i']: parname = par.attrib['name'].lower() kpts_params[parname] = __get_xml_parameter(par) kpts = elem.findall("varray[@name='kpointlist']/v") ibz_kpts = np.zeros((len(kpts), 3)) for i, kpt in enumerate(kpts): ibz_kpts[i] = [float(val) for val in kpt.text.split()] kpt_weights = elem.findall('varray[@name="weights"]/v') kpt_weights = [float(val.text) for val in kpt_weights] elif elem.tag == 'parameters': for par in elem.iter(): if par.tag in ['v', 'i']: parname = par.attrib['name'].lower() parameters[parname] = __get_xml_parameter(par) elif elem.tag == 'atominfo': species = [] for entry in elem.find("array[@name='atoms']/set"): species.append(entry[0].text.strip()) natoms = len(species) elif (elem.tag == 'structure' and elem.attrib.get('name') == 'initialpos'): cell_init = np.zeros((3, 3), dtype=float) for i, v in enumerate( elem.find("crystal/varray[@name='basis']")): cell_init[i] = np.array( [float(val) for val in v.text.split()]) scpos_init = np.zeros((natoms, 3), dtype=float) for i, v in enumerate( elem.find("varray[@name='positions']")): scpos_init[i] = np.array( [float(val) for val in v.text.split()]) constraints = [] fixed_indices = [] for i, entry in enumerate( elem.findall("varray[@name='selective']/v")): flags = (np.array( entry.text.split() == np.array(['F', 'F', 'F']))) if flags.all(): fixed_indices.append(i) elif flags.any(): constraints.append(FixScaled(cell_init, i, flags)) if fixed_indices: constraints.append(FixAtoms(fixed_indices)) atoms_init = Atoms(species, cell=cell_init, scaled_positions=scpos_init, constraint=constraints, pbc=True) elif elem.tag == 'dipole': dblock = elem.find('v[@name="dipole"]') if dblock is not None: dipole = np.array( [float(val) for val in dblock.text.split()]) elif event == 'start' and elem.tag == 'calculation': calculation.append(elem) except ET.ParseError as parse_error: if atoms_init is None: raise parse_error if calculation[-1].find('energy') is None: calculation = calculation[:-1] if not calculation: yield atoms_init if calculation: if isinstance(index, int): steps = [calculation[index]] else: steps = calculation[index] else: steps = [] for step in steps: # Workaround for VASP bug, e_0_energy contains the wrong value # in calculation/energy, but calculation/scstep/energy does not # include classical VDW corrections. So, first calculate # e_0_energy - e_fr_energy from calculation/scstep/energy, then # apply that correction to e_fr_energy from calculation/energy. lastscf = step.findall('scstep/energy')[-1] try: lastdipole = step.findall('scstep/dipole')[-1] except: lastdipole = None de = (float(lastscf.find('i[@name="e_0_energy"]').text) - float(lastscf.find('i[@name="e_fr_energy"]').text)) free_energy = float(step.find('energy/i[@name="e_fr_energy"]').text) energy = free_energy + de cell = np.zeros((3, 3), dtype=float) for i, vector in enumerate( step.find('structure/crystal/varray[@name="basis"]')): cell[i] = np.array([float(val) for val in vector.text.split()]) scpos = np.zeros((natoms, 3), dtype=float) for i, vector in enumerate( step.find('structure/varray[@name="positions"]')): scpos[i] = np.array([float(val) for val in vector.text.split()]) forces = None fblocks = step.find('varray[@name="forces"]') if fblocks is not None: forces = np.zeros((natoms, 3), dtype=float) for i, vector in enumerate(fblocks): forces[i] = np.array( [float(val) for val in vector.text.split()]) stress = None sblocks = step.find('varray[@name="stress"]') if sblocks is not None: stress = np.zeros((3, 3), dtype=float) for i, vector in enumerate(sblocks): stress[i] = np.array( [float(val) for val in vector.text.split()]) stress *= -0.1 * GPa stress = stress.reshape(9)[[0, 4, 8, 5, 2, 1]] dipole = None if lastdipole is not None: dblock = lastdipole.find('v[@name="dipole"]') if dblock is not None: dipole = np.zeros((1, 3), dtype=float) dipole = np.array([float(val) for val in dblock.text.split()]) dblock = step.find('dipole/v[@name="dipole"]') if dblock is not None: dipole = np.zeros((1, 3), dtype=float) dipole = np.array([float(val) for val in dblock.text.split()]) efermi = step.find('dos/i[@name="efermi"]') if efermi is not None: efermi = float(efermi.text) kpoints = [] for ikpt in range(1, len(ibz_kpts) + 1): kblocks = step.findall( 'eigenvalues/array/set/set/set[@comment="kpoint %d"]' % ikpt) if kblocks is not None: for spin, kpoint in enumerate(kblocks): eigenvals = kpoint.findall('r') eps_n = np.zeros(len(eigenvals)) f_n = np.zeros(len(eigenvals)) for j, val in enumerate(eigenvals): val = val.text.split() eps_n[j] = float(val[0]) f_n[j] = float(val[1]) if len(kblocks) == 1: f_n *= 2 kpoints.append( SinglePointKPoint(kpt_weights[ikpt - 1], spin, ikpt, eps_n, f_n)) if len(kpoints) == 0: kpoints = None atoms = atoms_init.copy() atoms.set_cell(cell) atoms.set_scaled_positions(scpos) atoms.set_calculator( SinglePointDFTCalculator(atoms, energy=energy, forces=forces, stress=stress, free_energy=free_energy, ibzkpts=ibz_kpts, efermi=efermi, dipole=dipole)) atoms.calc.name = 'vasp' atoms.calc.kpts = kpoints atoms.calc.parameters = parameters yield atoms
def read_gpaw_text(fileobj, index=-1): if isinstance(fileobj, str): fileobj = open(fileobj, 'rU') notfound = [] def index_startswith(lines, string): if string in notfound: raise ValueError for i, line in enumerate(lines): if line.startswith(string): return i notfound.append(string) raise ValueError lines = fileobj.readlines() images = [] while True: try: i = lines.index('Unit Cell:\n') except ValueError: pass else: cell = [] pbc = [] for line in lines[i + 3:i + 6]: words = line.split() if len(words) == 5: # old format cell.append(float(words[2])) pbc.append(words[1] == 'yes') else: # new format with GUC cell.append([float(word) for word in words[3:6]]) pbc.append(words[2] == 'yes') try: i = lines.index('Positions:\n') except ValueError: break symbols = [] positions = [] for line in lines[i + 1:]: words = line.split() if len(words) != 5: break n, symbol, x, y, z = words symbols.append(symbol.split('.')[0]) positions.append([float(x), float(y), float(z)]) if len(symbols): atoms = Atoms(symbols=symbols, positions=positions, cell=cell, pbc=pbc) else: atoms = Atoms(cell=cell, pbc=pbc) lines = lines[i + 5:] ene = { # key position 'Kinetic:': 1, 'Potential:': 2, 'XC:': 4 } try: i = lines.index('-------------------------\n') except ValueError: e = None else: for key in ene: pos = ene[key] ene[key] = None line = lines[i + pos] try: assert line.startswith(key) ene[key] = float(line.split()[-1]) except ValueError: pass line = lines[i + 9] assert line.startswith('Zero Kelvin:') e = float(line.split()[-1]) try: ii = index_startswith(lines, 'Fermi Level') except ValueError: eFermi = None else: try: eFermi = float(lines[ii].split()[2]) except ValueError: # we have two Fermi levels fields = lines[ii].split() def strip(string): for rubbish in '[],': string = string.replace(rubbish, '') return string eFermi = [float(strip(fields[2])), float(strip(fields[3]))] # read Eigenvalues and occupations ii1 = ii2 = 1e32 try: ii1 = index_startswith(lines, ' Band Eigenvalues Occupancy') except ValueError: pass try: ii2 = index_startswith(lines, ' Band Eigenvalues Occupancy') except ValueError: pass ii = min(ii1, ii2) if ii == 1e32: kpts = None else: ii += 1 words = lines[ii].split() vals = [] while (len(words) > 2): vals.append([float(word) for word in words]) ii += 1 words = lines[ii].split() vals = np.array(vals).transpose() kpts = [SinglePointKPoint(1, 0, 0)] kpts[0].eps_n = vals[1] kpts[0].f_n = vals[2] if vals.shape[0] > 3: kpts.append(SinglePointKPoint(1, 1, 0)) kpts[1].eps_n = vals[3] kpts[1].f_n = vals[4] # read charge try: ii = index_startswith(lines, 'Total Charge:') except ValueError: q = None else: q = float(lines[ii].split()[2]) # read dipole moment try: ii = index_startswith(lines, 'Dipole Moment:') except ValueError: dipole = None else: line = lines[ii].replace(']', '').replace('[', '') dipole = np.array([float(c) for c in line.split()[-3:]]) try: ii = index_startswith(lines, 'Local Magnetic Moments') except ValueError: magmoms = None else: magmoms = [] for i in range(ii + 1, ii + 1 + len(atoms)): iii, magmom = lines[i].split()[:2] magmoms.append(float(magmom)) try: ii = lines.index('Forces in eV/Ang:\n') except ValueError: f = None else: f = [] for i in range(ii + 1, ii + 1 + len(atoms)): try: x, y, z = lines[i].split()[-3:] f.append((float(x), float(y), float(z))) except (ValueError, IndexError), m: raise IOError('Malformed GPAW log file: %s' % m) if len(images) > 0 and e is None: break if q is not None and len(atoms) > 0: n = len(atoms) atoms.set_initial_charges([q / n] * n) if e is not None or f is not None: calc = SinglePointDFTCalculator(atoms, energy=e, forces=f, dipole=dipole, magmoms=magmoms, eFermi=eFermi) if kpts is not None: calc.kpts = kpts atoms.set_calculator(calc) images.append(atoms) lines = lines[i:]
def _read_outcar_frame(lines, header_data): from ase.calculators.singlepoint import (SinglePointDFTCalculator, SinglePointKPoint) mag_x = None mag_y = None mag_z = None magmoms = None magmom = None stress = None efermi = None symbols = header_data['symbols'] constraints = header_data['constraints'] natoms = header_data['natoms'] # nkpts = header_data['nkpts'] nbands = header_data['nbands'] kpt_weights = header_data['kpt_weights'] ibzkpts = header_data['ibzkpts'] atoms = Atoms(symbols=symbols, pbc=True, constraint=constraints) cl = _outcar_check_line # Aliasing spinc = 0 # Spin component kpts = [] forces = np.zeros((natoms, 3)) positions = np.zeros((natoms, 3)) f_n = np.zeros(nbands) # kpt occupations eps_n = np.zeros(nbands) # kpt eigenvalues # Parse each atoms object for n, line in enumerate(lines): line = line.strip() if 'direct lattice vectors' in line: cell = [] for i in range(3): parts = cl(lines[n + i + 1]).split() cell += [list(map(float, parts[0:3]))] atoms.set_cell(cell) elif 'magnetization (x)' in line: # Magnetization in both collinear and non-collinear nskip = 4 # Skip some lines mag_x = [float(cl(lines[n + i + nskip]).split()[-1]) for i in range(natoms)] # XXX: !!!Uncomment these lines when non-collinear spin is supported!!! # Remember to check that format fits! # elif 'magnetization (y)' in line: # # Non-collinear spin # nskip = 4 # Skip some lines # mag_y = [float(cl(lines[n + i + nskip]).split()[-1]) # for i in range(natoms)] # elif 'magnetization (z)' in line: # # Non-collinear spin # nskip = 4 # Skip some lines # mag_z = [float(cl(lines[n + i + nskip]).split()[-1]) # for i in range(natoms)] elif 'number of electron' in line: parts = cl(line).split() if len(parts) > 5 and parts[0].strip() != "NELECT": i = parts.index('magnetization') + 1 magmom = parts[i:] if len(magmom) == 1: # Collinear spin magmom = float(magmom[0]) # !Uncomment these lines when non-collinear spin is supported! # Remember to check that format fits! # else: # # Non-collinear spin # # Make a (3,) dim array # magmom = np.array(list(map(float, magmom))) elif 'in kB ' in line: stress = -np.asarray([float(a) for a in cl(line).split()[2:]]) stress = stress[[0, 1, 2, 4, 5, 3]] * 1e-1 * ase.units.GPa elif 'POSITION ' in line: nskip = 2 for i in range(natoms): parts = list(map(float, cl(lines[n + i + nskip]).split())) positions[i] = parts[0:3] forces[i] = parts[3:6] atoms.set_positions(positions, apply_constraint=False) elif 'E-fermi :' in line: parts = line.split() efermi = float(parts[2]) elif 'spin component' in line: # Update spin component for kpts # Make spin be in [0, 1], VASP writes 1 or 2 tmp = int(line.split()[-1]) - 1 if tmp < spinc: # if NWRITE=3, we write KPTS after every electronic step, # so we just reset it, since we went from spin=2 to spin=1 # in the same ionic step. # XXX: Only read it at last electronic step kpts = [] spinc = tmp elif 'k-point ' in line: if 'plane waves' in line: # Can happen if we still have part of header continue # Parse all kpts and bands parts = line.split() ikpt = int(parts[1]) - 1 # Make kpt idx start from 0 w = kpt_weights[ikpt] nskip = 2 for i in range(nbands): parts = lines[n + i + nskip].split() eps_n[i] = float(parts[1]) f_n[i] = float(parts[2]) kpts.append(SinglePointKPoint(w, spinc, ikpt, eps_n=eps_n, f_n=f_n)) elif _OUTCAR_SCF_DELIM in line: # Last section before next ionic step nskip = 2 parts = cl(lines[n + nskip]).strip().split() energy_free = float(parts[4]) # Force consistent nskip = 4 parts = cl(lines[n + nskip]).strip().split() energy_zero = float(parts[6]) # Extrapolated to 0 K # For debugging # assert len(kpts) == 0 or len(kpts) == (spinc + 1) * nkpts if mag_x is not None: if mag_y is not None: # Non-collinear assert len(mag_x) == len(mag_y) == len(mag_z) magmoms = np.zeros((len(atoms), 3)) magmoms[:, 0] = mag_x magmoms[:, 1] = mag_y magmoms[:, 2] = mag_z else: # Collinear magmoms = np.array(mag_x) atoms.set_calculator( SinglePointDFTCalculator(atoms, energy=energy_zero, free_energy=energy_free, ibzkpts=ibzkpts, forces=forces, efermi=efermi, magmom=magmom, magmoms=magmoms, stress=stress)) atoms.calc.name = 'vasp' atoms.calc.kpts = kpts return atoms
from ase.atoms import Atoms from ase.calculators.singlepoint import SinglePointDFTCalculator from ase.calculators.singlepoint import SinglePointKPoint from ase.dft.dos import DOS atoms = Atoms('H') eFermi = [0, 1] kpts = [SinglePointKPoint(1, 0, 0), SinglePointKPoint(1, 1, 0)] kpts[0].eps_n = [-2, -1, 1] kpts[0].f_n = [1, 0, 0] kpts[1].eps_n = [-2.5, -1.5, 0.5] kpts[1].f_n = [1, 0, 0] calc = SinglePointDFTCalculator(atoms, efermi=eFermi) calc.kpts = kpts dos = DOS(calc)
def read_pw_out(fileobj, index=-1, results_required=True): """Reads Quantum ESPRESSO output files. The atomistic configurations as well as results (energy, force, stress, magnetic moments) of the calculation are read for all configurations within the output file. Will probably raise errors for broken or incomplete files. Parameters ---------- fileobj : file|str A file like object or filename index : slice The index of configurations to extract. results_required : bool If True, atomistic configurations that do not have any associated results will not be included. This prevents double printed configurations and incomplete calculations from being returned as the final configuration with no results data. Yields ------ structure : Atoms The next structure from the index slice. The Atoms has a SinglePointCalculator attached with any results parsed from the file. """ if isinstance(fileobj, str): fileobj = open(fileobj, 'rU') # work with a copy in memory for faster random access pwo_lines = fileobj.readlines() # TODO: index -1 special case? # Index all the interesting points indexes = { _PW_START: [], _PW_END: [], _PW_CELL: [], _PW_POS: [], _PW_MAGMOM: [], _PW_FORCE: [], _PW_TOTEN: [], _PW_STRESS: [], _PW_FERMI: [], _PW_HIGHEST_OCCUPIED: [], _PW_HIGHEST_OCCUPIED_LOWEST_FREE: [], _PW_KPTS: [], _PW_BANDS: [], _PW_BANDSTRUCTURE: [], _PW_ELECTROSTATIC_EMBEDDING: [], _PW_NITER: [], _PW_DONE: [], _PW_WALLTIME: [] } for idx, line in enumerate(pwo_lines): for identifier in indexes: if identifier in line: indexes[identifier].append(idx) # Configurations are either at the start, or defined in ATOMIC_POSITIONS # in a subsequent step. Can deal with concatenated output files. all_config_indexes = sorted(indexes[_PW_START] + indexes[_PW_POS]) # Slice only requested indexes # setting results_required argument stops configuration-only # structures from being returned. This ensures the [-1] structure # is one that has results. Two cases: # - SCF of last configuration is not converged, job terminated # abnormally. # - 'relax' and 'vc-relax' re-prints the final configuration but # only 'vc-relax' recalculates. if results_required: results_indexes = sorted(indexes[_PW_TOTEN] + indexes[_PW_FORCE] + indexes[_PW_STRESS] + indexes[_PW_MAGMOM] + indexes[_PW_BANDS] + indexes[_PW_ELECTROSTATIC_EMBEDDING] + indexes[_PW_BANDSTRUCTURE]) # Prune to only configurations with results data before the next # configuration results_config_indexes = [] for config_index, config_index_next in zip( all_config_indexes, all_config_indexes[1:] + [len(pwo_lines)]): if any([ config_index < results_index < config_index_next for results_index in results_indexes ]): results_config_indexes.append(config_index) # slice from the subset image_indexes = results_config_indexes[index] else: image_indexes = all_config_indexes[index] # Extract initialisation information each time PWSCF starts # to add to subsequent configurations. Use None so slices know # when to fill in the blanks. pwscf_start_info = dict((idx, None) for idx in indexes[_PW_START]) if isinstance(image_indexes, int): image_indexes = [image_indexes] for image_index in image_indexes: # Find the nearest calculation start to parse info. Needed in, # for example, relaxation where cell is only printed at the # start. if image_index in indexes[_PW_START]: prev_start_index = image_index else: # The greatest start index before this structure prev_start_index = [ idx for idx in indexes[_PW_START] if idx < image_index ][-1] # add structure to reference if not there if pwscf_start_info[prev_start_index] is None: pwscf_start_info[prev_start_index] = parse_pwo_start( pwo_lines, prev_start_index) # Get the bounds for information for this structure. Any associated # values will be between the image_index and the following one, # EXCEPT for cell, which will be 4 lines before if it exists. for next_index in all_config_indexes: if next_index > image_index: break else: # right to the end of the file next_index = len(pwo_lines) # Get the structure # Use this for any missing data prev_structure = pwscf_start_info[prev_start_index]['atoms'] if image_index in indexes[_PW_START]: structure = prev_structure.copy() # parsed from start info else: if _PW_CELL in pwo_lines[image_index - 5]: # CELL_PARAMETERS would be just before positions if present cell, cell_alat = get_cell_parameters(pwo_lines[image_index - 5:image_index]) else: cell = prev_structure.cell cell_alat = pwscf_start_info[prev_start_index]['alat'] # give at least enough lines to parse the positions # should be same format as input card n_atoms = len(prev_structure) positions_card = get_atomic_positions( pwo_lines[image_index:image_index + n_atoms + 1], n_atoms=n_atoms, cell=cell, alat=cell_alat) # convert to Atoms object symbols = [ label_to_symbol(position[0]) for position in positions_card ] tags = [label_to_tag(position[0]) for position in positions_card] positions = [position[1] for position in positions_card] constraint_idx = [position[2] for position in positions_card] constraint = get_constraint(constraint_idx) structure = Atoms(symbols=symbols, positions=positions, cell=cell, constraint=constraint, pbc=True, tags=tags) # Extract calculation results # Energy energy = None for energy_index in indexes[_PW_TOTEN]: if image_index < energy_index < next_index: energy = float( pwo_lines[energy_index].split()[-2]) * units['Ry'] # Electrostatic enbedding energy elec_embedding_energy = None for eee_index in indexes[_PW_ELECTROSTATIC_EMBEDDING]: if image_index < eee_index < next_index: elec_embedding_energy = float( pwo_lines[eee_index].split()[-2]) * units['Ry'] # Number of iterations n_iterations = None for niter_index in indexes[_PW_NITER]: if image_index < niter_index < next_index: n_iterations = int( pwo_lines[niter_index].split('#')[1].split()[0]) # Forces forces = None for force_index in indexes[_PW_FORCE]: if image_index < force_index < next_index: # Before QE 5.3 'negative rho' added 2 lines before forces # Use exact lines to stop before 'non-local' forces # in high verbosity if not pwo_lines[force_index + 2].strip(): force_index += 4 else: force_index += 2 # assume contiguous forces = [[float(x) for x in force_line.split()[-3:]] for force_line in pwo_lines[force_index:force_index + len(structure)]] forces = np.array(forces) * units['Ry'] / units['Bohr'] # Stress stress = None for stress_index in indexes[_PW_STRESS]: if image_index < stress_index < next_index: sxx, sxy, sxz = pwo_lines[stress_index + 1].split()[:3] _, syy, syz = pwo_lines[stress_index + 2].split()[:3] _, _, szz = pwo_lines[stress_index + 3].split()[:3] stress = np.array([sxx, syy, szz, syz, sxz, sxy], dtype=float) # sign convention is opposite of ase stress *= -1 * units['Ry'] / (units['Bohr']**3) # Magmoms magmoms = None for magmoms_index in indexes[_PW_MAGMOM]: if image_index < magmoms_index < next_index: magmoms = [ float(mag_line.split('=')[-1]) for mag_line in pwo_lines[magmoms_index + 1:magmoms_index + 1 + len(structure)] ] # Fermi level / highest occupied level and lowest unoccupied level efermi = None lumo_ene = None for fermi_index in indexes[_PW_FERMI]: if image_index < fermi_index < next_index: efermi = float(pwo_lines[fermi_index].split()[-2]) if efermi is None: for ho_index in indexes[_PW_HIGHEST_OCCUPIED]: if image_index < ho_index < next_index: efermi = float(pwo_lines[ho_index].split()[-1]) if efermi is None: for holf_index in indexes[_PW_HIGHEST_OCCUPIED_LOWEST_FREE]: if image_index < holf_index < next_index: efermi = float(pwo_lines[holf_index].split()[-2]) lumo_ene = float(pwo_lines[holf_index].split()[-1]) # K-points ibzkpts = None weights = None kpoints_warning = "Number of k-points >= 100: " + \ "set verbosity='high' to print them." for kpts_index in indexes[_PW_KPTS]: nkpts = int(pwo_lines[kpts_index].split()[4]) kpts_index += 2 if pwo_lines[kpts_index].strip() == kpoints_warning: continue # QE prints the k-points in units of 2*pi/alat # with alat defined as the length of the first # cell vector cell = structure.get_cell() alat = np.linalg.norm(cell[0]) ibzkpts = [] weights = [] for i in range(nkpts): L = pwo_lines[kpts_index + i].split() weights.append(float(L[-1])) coord = np.array([L[-6], L[-5], L[-4].strip('),')], dtype=float) coord *= 2 * np.pi / alat coord = kpoint_convert(cell, ckpts_kv=coord) ibzkpts.append(coord) ibzkpts = np.array(ibzkpts) weights = np.array(weights) # Bands kpts = None kpoints_warning = "Number of k-points >= 100: " + \ "set verbosity='high' to print the bands." for bands_index in indexes[_PW_BANDS] + indexes[_PW_BANDSTRUCTURE]: if image_index < bands_index < next_index: bands_index += 2 if pwo_lines[bands_index].strip() == kpoints_warning: continue assert ibzkpts is not None spin, bands, eigenvalues = 0, [], [[], []] while True: L = pwo_lines[bands_index].replace('-', ' -').split() if len(L) == 0: if len(bands) > 0: eigenvalues[spin].append(bands) bands = [] elif L == ['occupation', 'numbers']: # Skip the lines with the occupation numbers bands_index += len(eigenvalues[spin][0]) // 8 + 1 elif L[0] == 'k' and L[1].startswith('='): pass elif 'SPIN' in L: if 'DOWN' in L: spin += 1 else: try: bands.extend(map(float, L)) except ValueError: break bands_index += 1 if spin == 1: assert len(eigenvalues[0]) == len(eigenvalues[1]) # assert len(eigenvalues[0]) == len(ibzkpts), \ # (np.shape(eigenvalues), len(ibzkpts)) kpts = [] for s in range(spin + 1): for w, k, e in zip(weights, ibzkpts, eigenvalues[s]): kpt = SinglePointKPoint(w, s, k, eps_n=e) kpts.append(kpt) # Convergence job_done = False for done_index in indexes[_PW_DONE]: if image_index < done_index < next_index: job_done = True # Walltime walltime = None for wt_index in indexes[_PW_WALLTIME]: if image_index < wt_index < next_index: walltime = time_to_float(pwo_lines[wt_index].split()[-2]) # Put everything together calc = SinglePointDFTCalculator(structure, energy=energy, forces=forces, stress=stress, magmoms=magmoms, efermi=efermi, ibzkpts=ibzkpts) calc.results['homo_energy'] = efermi calc.results['lumo_energy'] = lumo_ene calc.results['electrostatic embedding'] = elec_embedding_energy calc.results['iterations'] = n_iterations calc.results['job done'] = job_done calc.results['walltime'] = walltime calc.kpts = kpts structure.calc = calc yield structure