def test_get_structure_max4(load_inpxml, data_regression):
from masci_tools.util.xml.xml_getters import get_structure_data
from masci_tools.io.common_functions import convert_to_pystd
xmltree, schema_dict = load_inpxml(TEST_MAX4_INPXML_PATH)
atoms, cell, pbc = get_structure_data(xmltree, schema_dict)
data_regression.check({
'atoms': convert_to_pystd(atoms),
'cell': convert_to_pystd(cell),
'pbc': pbc
})
def test_hdf5_reader_jdos(data_regression):
"""
Tests of the dos recipe (also pass opened file handle)
"""
from masci_tools.io.parsers.hdf5 import HDF5Reader
from masci_tools.io.parsers.hdf5.recipes import FleurJDOS
TEST_BANDDOS_FILE = os.path.join(HDFTEST_DIR, 'banddos_spinpol_dos.hdf')
with HDF5Reader(TEST_BANDDOS_FILE) as reader:
data, attrs = reader.read(recipe=FleurJDOS)
data_regression.check({
'datasets': convert_to_pystd(data),
'attributes': convert_to_pystd(attrs)
})
def test_hdf5_reader_bands(data_regression):
"""
Tests of the bands recipe
"""
from masci_tools.io.parsers.hdf5 import HDF5Reader
from masci_tools.io.parsers.hdf5.recipes import FleurBands
TEST_BANDDOS_FILE = os.path.join(HDFTEST_DIR, 'banddos_bands.hdf')
with HDF5Reader(TEST_BANDDOS_FILE) as reader:
data, attrs = reader.read(recipe=FleurBands)
data_regression.check({
'datasets': convert_to_pystd(data),
'attributes': convert_to_pystd(attrs)
})
def test_get_cell_bulk(load_inpxml, data_regression):
from masci_tools.util.xml.xml_getters import get_cell
from masci_tools.io.common_functions import convert_to_pystd
xmltree, schema_dict = load_inpxml(TEST_BULK_INPXML_PATH)
cell, pbc = get_cell(xmltree, schema_dict)
data_regression.check({'cell': convert_to_pystd(cell), 'pbc': pbc})
def test_kpoints_max4(load_inpxml, data_regression):
from masci_tools.util.xml.xml_getters import get_kpoints_data
from masci_tools.io.common_functions import convert_to_pystd
xmltree, schema_dict = load_inpxml(TEST_MAX4_INPXML_PATH)
kpoints, weights, cell, pbc = get_kpoints_data(xmltree, schema_dict)
data_regression.check({
'kpoints': kpoints,
'weights': weights,
'cell': convert_to_pystd(cell),
'pbc': pbc
})
def test_kpoints_multiple_sets_selection_index(load_inpxml, data_regression):
from masci_tools.util.xml.xml_getters import get_kpoints_data
from masci_tools.io.common_functions import convert_to_pystd
xmltree, schema_dict = load_inpxml(TEST_MULTIPLE_KPOINT_SETS_PATH)
kpoints, weights, cell, pbc = get_kpoints_data(xmltree,
schema_dict,
index=0)
data_regression.check({
'kpoints': kpoints,
'weights': weights,
'cell': convert_to_pystd(cell),
'pbc': pbc
})
def calculate_total_magnetic_moment(out_dict, logger):
"""
Calculate the the total magnetic moment per cell
:param out_dict: dict with the already parsed information
"""
total_charge = out_dict.get('spin_dependent_charge_total', None)
if total_charge is None:
if logger is not None:
logger.warning('calculate_total_magnetic_moment got None')
return out_dict
total_charge = total_charge[-1]
if isinstance(total_charge, list):
if 'total_magnetic_moment_cell' not in out_dict:
out_dict['total_magnetic_moment_cell'] = []
out_dict['total_magnetic_moment_cell'].append(
convert_to_pystd(np.abs(total_charge[0] - total_charge[1])))
return out_dict
def parse_kkr_outputfile(out_dict,
outfile,
outfile_0init,
outfile_000,
timing_file,
potfile_out,
nonco_out_file,
outfile_2='output.2.txt',
skip_readin=False):
"""
Parser method for the kkr outfile. It returns a dictionary with results
"""
# scaling factors etc. defined globally
Ry2eV = get_Ry2eV()
doscalc = False
# collection of parsing error messages
msg_list = []
try:
code_version, compile_options, serial_number = get_version_info(
outfile)
tmp_dict = {}
tmp_dict['code_version'] = code_version
tmp_dict['compile_options'] = compile_options
tmp_dict['calculation_serial_number'] = serial_number
out_dict['code_info_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: Version Info"
msg_list.append(msg)
try:
nspin = get_nspin(outfile_0init)
natom = get_natom(outfile_0init)
newsosol = use_newsosol(outfile_0init)
out_dict['nspin'] = nspin
out_dict['number_of_atoms_in_unit_cell'] = natom
out_dict['use_newsosol'] = newsosol
except:
msg = "Error parsing output of KKR: nspin/natom"
msg_list.append(msg)
try:
result = find_warnings(outfile)
tmp_dict = {}
tmp_dict['number_of_warnings'] = len(result)
tmp_dict['warnings_list'] = result
out_dict['warnings_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: search for warnings"
msg_list.append(msg)
try:
result = extract_timings(timing_file)
out_dict['timings_group'] = result
out_dict['timings_unit'] = 'seconds'
except:
msg = "Error parsing output of KKR: timings"
msg_list.append(msg)
try:
emin, tempr, Nepts, Npol, N1, N2, N3 = get_econt_info(outfile_0init)
tmp_dict = {}
tmp_dict['emin'] = emin
tmp_dict['emin_unit'] = 'Rydberg'
tmp_dict['number_of_energy_points'] = Nepts
tmp_dict['temperature'] = tempr
tmp_dict['temperature_unit'] = 'Kelvin'
tmp_dict['npol'] = Npol
tmp_dict['n1'] = N1
tmp_dict['n2'] = N2
tmp_dict['n3'] = N3
out_dict['energy_contour_group'] = tmp_dict
if Npol == 0:
doscalc = True
except:
msg = "Error parsing output of KKR: energy contour"
msg_list.append(msg)
try:
alat, twopioveralat = get_alatinfo(outfile_0init)
out_dict['alat_internal'] = alat
out_dict['two_pi_over_alat_internal'] = twopioveralat
out_dict['alat_internal_unit'] = 'a_Bohr'
out_dict['two_pi_over_alat_internal_unit'] = '1/a_Bohr'
except:
msg = "Error parsing output of KKR: alat, 2*pi/alat"
msg_list.append(msg)
try:
nkmesh, kmesh_ie = get_kmeshinfo(outfile_0init, outfile_000)
tmp_dict = {}
tmp_dict['number_different_kmeshes'] = nkmesh[0]
tmp_dict['number_kpoints_per_kmesh'] = nkmesh[1]
tmp_dict['kmesh_energypoint'] = kmesh_ie
out_dict['kmesh_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: kmesh"
msg_list.append(msg)
try:
nsym, nsym_used, desc = get_symmetries(outfile_0init)
tmp_dict = {}
tmp_dict['number_of_lattice_symmetries'] = nsym
tmp_dict['number_of_used_symmetries'] = nsym_used
tmp_dict['symmetry_description'] = desc
out_dict['symmetries_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: symmetries"
msg_list.append(msg)
if not doscalc: # in case of dos calculation no ewald summation is done
try:
rsum, gsum, info = get_ewald(outfile_0init)
tmp_dict = {}
tmp_dict['ewald_summation_mode'] = info
tmp_dict['rsum_cutoff'] = rsum[0]
tmp_dict['rsum_number_of_vectors'] = rsum[1]
tmp_dict['rsum_number_of_shells'] = rsum[2]
tmp_dict['rsum_cutoff_unit'] = 'a_Bohr'
tmp_dict['gsum_cutoff'] = gsum[0]
tmp_dict['gsum_number_of_vectors'] = gsum[1]
tmp_dict['gsum_number_of_shells'] = gsum[2]
tmp_dict['gsum_cutoff_unit'] = '1/a_Bohr'
out_dict['ewald_sum_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: ewald summation for madelung poterntial"
msg_list.append(msg)
try:
bv, recbv = get_lattice_vectors(outfile_0init)
out_dict['direct_bravais_matrix'] = bv
out_dict['reciprocal_bravais_matrix'] = recbv
out_dict['direct_bravais_matrix_unit'] = 'alat'
out_dict['reciprocal_bravais_matrix_unit'] = '2*pi / alat'
except:
msg = "Error parsing output of KKR: lattice vectors (direct/reciprocal)"
msg_list.append(msg)
# this is skipped for qdos run for example
if not skip_readin:
try:
ncore, emax, lmax, descr_max = get_core_states(potfile_out)
tmp_dict = {}
tmp_dict['number_of_core_states_per_atom'] = ncore
tmp_dict['energy_highest_lying_core_state_per_atom'] = emax
tmp_dict[
'energy_highest_lying_core_state_per_atom_unit'] = 'Rydberg'
tmp_dict['descr_highest_lying_core_state_per_atom'] = descr_max
out_dict['core_states_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: core_states"
msg_list.append(msg)
tmp_dict = {
} # used to group convergence info (rms, rms per atom, charge neutrality)
# also initialize convegence_group where all info stored for all iterations is kept
out_dict['convergence_group'] = tmp_dict
try:
result, result_atoms_last = get_rms(outfile, outfile_000)
tmp_dict['rms'] = result[-1]
tmp_dict['rms_all_iterations'] = result
tmp_dict['rms_per_atom'] = result_atoms_last
tmp_dict['rms_unit'] = 'unitless'
out_dict['convergence_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: rms-error"
msg_list.append(msg)
try:
result = get_neutr(outfile)
tmp_dict['charge_neutrality'] = result[-1]
out_dict['convergence_group'][
'charge_neutrality_all_iterations'] = result
tmp_dict['charge_neutrality_unit'] = 'electrons'
out_dict['convergence_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: charge neutrality"
msg_list.append(msg)
tmp_dict = {
} # used to group magnetism info (spin and orbital moments)
try:
result = get_magtot(outfile)
if len(result) > 0:
tmp_dict['total_spin_moment'] = result[-1]
out_dict['convergence_group'][
'total_spin_moment_all_iterations'] = result
tmp_dict['total_spin_moment_unit'] = 'mu_Bohr'
out_dict['magnetism_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: total magnetic moment"
msg_list.append(msg)
try:
if nspin > 1:
if not newsosol:
#reset automatically to None to turn off reading of nonco angles file
nonco_out_file = None
result, vec, angles = get_spinmom_per_atom(
outfile, natom, nonco_out_file)
if len(result) > 0:
tmp_dict['spin_moment_per_atom'] = result[-1, :]
if newsosol:
tmp_dict['spin_moment_vector_per_atom'] = vec[:]
tmp_dict['spin_moment_angles_per_atom'] = angles[:]
tmp_dict['spin_moment_angles_per_atom_unit'] = 'degree'
out_dict['convergence_group'][
'spin_moment_per_atom_all_iterations'] = result[:, :]
tmp_dict['spin_moment_unit'] = 'mu_Bohr'
out_dict['magnetism_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: spin moment per atom"
msg_list.append(msg)
# add orbital moments to magnetis group in parser output
try:
if nspin > 1 and newsosol:
#TODO orbital moment full vectors
# so far the KKR code writes only the component of the orbital moment
# parallel to the spin moment, thus vec and angles are returned empty
# by construction. This might change in the future
#result, vec, angles = get_orbmom(outfile, natom, nonco_angles_orbmom)
# so for now return only result= array containing all iterations, all atoms, orbital moment parallel to spin quantization axis
result = get_orbmom(outfile, natom)
if len(result) > 0:
tmp_dict['total_orbital_moment'] = sum(result[-1, :])
tmp_dict['orbital_moment_per_atom'] = result[-1, :]
#tmp_dict['orbital_moment_vector_per_atom'] = vec[-1,:]
#tmp_dict['orbital_moment_angles_per_atom'] = angles[-1,:]
out_dict['convergence_group'][
'orbital_moment_per_atom_all_iterations'] = result[:, :]
tmp_dict['orbital_moment_unit'] = 'mu_Bohr'
#tmp_dict['orbital_moment_angles_per_atom_unit'] = 'degree'
out_dict['magnetism_group'] = tmp_dict
except:
msg = "Error parsing output of KKR: orbital moment"
msg_list.append(msg)
try:
result = get_EF(outfile)
out_dict['fermi_energy'] = result[-1]
out_dict['fermi_energy_units'] = 'Ry'
out_dict['convergence_group'][
'fermi_energy_all_iterations'] = result
out_dict['convergence_group'][
'fermi_energy_all_iterations_units'] = 'Ry'
except:
msg = "Error parsing output of KKR: EF"
msg_list.append(msg)
try:
result = get_DOS_EF(outfile)
out_dict['dos_at_fermi_energy'] = result[-1]
out_dict['convergence_group'][
'dos_at_fermi_energy_all_iterations'] = result
except:
msg = "Error parsing output of KKR: DOS@EF"
msg_list.append(msg)
try:
result = get_Etot(outfile)
out_dict['energy'] = result[-1] * Ry2eV
out_dict['energy_unit'] = 'eV'
out_dict['total_energy_Ry'] = result[-1]
out_dict['total_energy_Ry_unit'] = 'Rydberg'
out_dict['convergence_group'][
'total_energy_Ry_all_iterations'] = result
except:
msg = "Error parsing output of KKR: total energy"
msg_list.append(msg)
try:
result = get_single_particle_energies(outfile_000)
out_dict['single_particle_energies'] = result * Ry2eV
out_dict['single_particle_energies_unit'] = 'eV'
except:
msg = "Error parsing output of KKR: single particle energies"
msg_list.append(msg)
try:
result_WS, result_tot, result_C = get_charges_per_atom(outfile_000)
niter = len(out_dict['convergence_group']['rms_all_iterations'])
natyp = int(len(result_tot) // niter)
out_dict['total_charge_per_atom'] = result_tot[-natyp:]
out_dict['charge_core_states_per_atom'] = result_C[-natyp:]
# this check deals with the DOS case where output is slightly different
if len(result_WS) == len(result_C):
out_dict['charge_valence_states_per_atom'] = result_WS[
-natyp:] - result_C[-natyp:]
out_dict['total_charge_per_atom_unit'] = 'electron charge'
out_dict['charge_core_states_per_atom_unit'] = 'electron charge'
out_dict['charge_valence_states_per_atom_unit'] = 'electron charge'
except:
msg = "Error parsing output of KKR: charges"
msg_list.append(msg)
try:
try:
niter, nitermax, converged, nmax_reached, mixinfo = get_scfinfo(
outfile_0init, outfile_000, outfile)
except IndexError:
niter, nitermax, converged, nmax_reached, mixinfo = get_scfinfo(
outfile_0init, outfile_2, outfile)
out_dict['convergence_group']['number_of_iterations'] = niter
out_dict['convergence_group'][
'number_of_iterations_max'] = nitermax
out_dict['convergence_group']['calculation_converged'] = converged
out_dict['convergence_group']['nsteps_exhausted'] = nmax_reached
out_dict['convergence_group']['imix'] = mixinfo[0]
out_dict['convergence_group']['strmix'] = mixinfo[1]
out_dict['convergence_group']['qbound'] = mixinfo[2]
out_dict['convergence_group']['fcm'] = mixinfo[3]
out_dict['convergence_group']['idtbry'] = mixinfo[4]
out_dict['convergence_group']['brymix'] = mixinfo[5]
except:
msg = "Error parsing output of KKR: scfinfo"
msg_list.append(msg)
#convert numpy arrays to standard python lists
out_dict = convert_to_pystd(out_dict)
# return output with error messages if there are any
if len(msg_list) > 0:
return False, msg_list, out_dict
else:
return True, [], out_dict
def parse_voronoi_output(out_dict, outfile, potfile, atominfo, radii,
inputfile):
"""
Parse output of voronoi calculation and return (success, error_messages_list, out_dict)
"""
# for collection of error messages:
msg_list = []
try:
code_version, compile_options, serial_number = get_version_info(
outfile)
tmp_dict = {}
tmp_dict['code_version'] = code_version
tmp_dict['compile_options'] = compile_options
tmp_dict['calculation_serial_number'] = serial_number
out_dict['code_info_group'] = tmp_dict
except:
msg = "Error parsing output of voronoi: Version Info"
msg_list.append(msg)
try:
emin, e_core_max = check_voronoi_output(potfile, outfile)
out_dict['emin'] = emin
out_dict['emin_units'] = 'Ry'
diff_emin_ef = emin - get_ef_from_potfile(potfile)
out_dict['emin_minus_efermi_Ry'] = diff_emin_ef
out_dict['emin_minus_efermi'] = diff_emin_ef * get_Ry2eV()
out_dict['emin_minus_efermi_Ry_units'] = 'Ry'
out_dict['emin_minus_efermi_units'] = 'eV'
except:
msg = "Error parsing output of voronoi: 'EMIN'"
msg_list.append(msg)
# parse
try:
ncore, emax, lmax, descr_max = get_core_states(potfile)
tmp_dict = {}
tmp_dict['number_of_core_states_per_atom'] = ncore
tmp_dict['energy_highest_lying_core_state_per_atom'] = emax
tmp_dict['energy_highest_lying_core_state_per_atom_unit'] = 'Rydberg'
tmp_dict['descr_highest_lying_core_state_per_atom'] = descr_max
out_dict['core_states_group'] = tmp_dict
except:
msg = "Error parsing output of voronoi: core_states"
msg_list.append(msg)
try:
Ncls, natom, results = get_cls_info(outfile)
clsinfo = []
tmpdict_all = {}
for icls in range(natom):
tmpdict = {}
tmpdict['iatom'] = results[icls][0]
tmpdict['refpot'] = results[icls][1]
tmpdict['rmt_ref'] = results[icls][2]
tmpdict['tb_cluster_id'] = results[icls][3]
tmpdict['sites'] = results[icls][4]
clsinfo.append(tmpdict)
tmpdict_all['cluster_info_atoms'] = clsinfo
tmpdict_all['number_of_clusters'] = Ncls
out_dict['cluster_info_group'] = tmpdict_all
except:
msg = "Error parsing output of voronoi: Cluster Info"
msg_list.append(msg)
try:
out_dict['start_from_jellium_potentials'] = startpot_jellium(outfile)
except:
msg = "Error parsing output of voronoi: Jellium startpot"
msg_list.append(msg)
try:
natyp, naez, shapes = get_shape_array(outfile, atominfo)
out_dict['shapes'] = shapes
except:
msg = "Error parsing output of voronoi: SHAPE Info"
msg_list.append(msg)
try:
Vtot, results = get_volumes(outfile)
tmp_dict = {}
tmp_dict['volume_total'] = Vtot
tmpdict_all = []
for icls in range(naez):
tmpdict = {}
tmpdict['iatom'] = results[icls][0]
tmpdict['v_atom'] = results[icls][1]
tmpdict_all.append(tmpdict)
tmp_dict['volume_atoms'] = tmpdict_all
tmp_dict['volume_unit'] = 'alat^3'
out_dict['volumes_group'] = tmp_dict
except:
msg = "Error parsing output of voronoi: Volume Info"
msg_list.append(msg)
try:
results = get_radii(naez, radii)
tmpdict_all = []
for icls in range(naez):
tmpdict = {}
tmpdict['iatom'] = results[icls][0]
tmpdict['rmt0'] = results[icls][1]
tmpdict['rout'] = results[icls][2]
tmpdict['dist_nn'] = results[icls][4]
tmpdict['rmt0_over_rout'] = results[icls][3]
tmpdict['rout_over_dist_nn'] = results[icls][5]
tmpdict_all.append(tmpdict)
tmpdict_all.append({'radii_units': 'alat'})
out_dict['radii_atoms_group'] = tmpdict_all
except:
msg = "Error parsing output of voronoi: radii.dat Info"
msg_list.append(msg)
try:
results = get_fpradius(naez, atominfo)
out_dict['fpradius_atoms'] = results
out_dict['fpradius_atoms_unit'] = 'alat'
except:
msg = "Error parsing output of voronoi: full potential radius"
msg_list.append(msg)
try:
result = get_alat(inputfile)
out_dict['alat'] = result
out_dict['alat_unit'] = 'a_Bohr'
except:
msg = "Error parsing output of voronoi: alat"
msg_list.append(msg)
try:
result = get_radial_meshpoints(potfile)
out_dict['radial_meshpoints'] = result
except:
msg = "Error parsing output of voronoi: radial meshpoints"
msg_list.append(msg)
# some consistency checks comparing lists with natyp/naez numbers
#TODO implement checks
#convert numpy arrays to standard python lists
out_dict = convert_to_pystd(out_dict)
# return output with error messages if there are any
if len(msg_list) > 0:
return False, msg_list, out_dict
else:
return True, [], out_dict
def test_convert_to_pystd(self):
test = {
'list': [0, 1, 2],
'nparray': np.array([0, 1, 2]),
'nparray_conv_list': list(np.array([0, 1, 2])),
'int': 9,
'float': 0.9,
'np.int': np.int64(8),
'np.float': np.float128(9),
'dict': {
'list': [0, 1, 2],
'nparray': np.array([0, 1, 2]),
'nparray_conv_list': list(np.array([0, 1, 2])),
'int': 9,
'float': 0.9,
'np.int': np.int64(8),
'np.float': np.float128(9),
'dict': {
'list': [0, 1, 2],
'nparray': np.array([0, 1, 2]),
'nparray_conv_list': list(np.array([0, 1, 2])),
'int': 9,
'float': 0.9,
'np.int': np.int64(8),
'np.float': np.float128(9)
}
}
}
# make a copy and convert the dict
test1 = test.copy()
test1 = convert_to_pystd(test1)
print('original ', test)
print('converted', test1)
# extract datatypes for comparison
for i in [
'list', 'nparray', 'nparray_conv_list', 'int', 'float',
'np.int', 'np.float'
]:
ii = test[i]
if i == 'list':
out0 = []
print(i, type(ii))
out0.append(type(ii))
if i in ['list', 'nparray', 'nparray_conv_list']:
for j in ii:
print(j, type(j))
out0.append(type(j))
# converted datatypes:
ii = test1[i]
if i == 'list':
out = []
print(i, type(ii))
out.append(type(ii))
if i in ['list', 'nparray', 'nparray_conv_list']:
for j in ii:
print(j, type(j))
out.append(type(j))
# now compare datatypes:
assert out0 == [
list, int, int, int, np.ndarray, np.int64, np.int64, np.int64,
list, int, int, int, int, float, np.int64, np.float128
]
assert out == [
list, int, int, int, list, int, int, int, list, int, int, int, int,
float, int, float
]
def parse_kkrimp_outputfile(self, out_dict, file_dict, debug=False):
"""
Main parser function for kkrimp, read information from files in file_dict and fills out_dict
:param out_dict: dictionary that is filled with parsed output of the KKRimp calculation
:param file_dict: dictionary of files that are parsed
:returns: success (bool), msg_list(list of error/warning messages of parser), out_dict (filled dict of parsed output)
:note: file_dict should contain the following keys
- 'outfile', the std_out of the KKRimp calculation
- 'out_log', the out_log.000.txt file
- 'out_pot', the output potential
- 'out_enersp_at', the out_energysp_per_atom_eV file
- 'out_enertot_at', the out_energytotal_per_atom_eV file
- 'out_timing', the timing file
- 'kkrflex_llyfac', the file for the Lloyd factor
- 'kkrflex_angles', the nonco_angles file for the KKRimp calculation
- 'out_spinmoms', the output spin moments file
- 'out_orbmoms', the output orbital moments file
"""
msg_list = []
files = file_dict
try:
code_version, compile_options, serial_number = get_version_info(
files['out_log'])
tmp_dict = {}
tmp_dict['code_version'] = code_version
tmp_dict['compile_options'] = compile_options
tmp_dict['calculation_serial_number'] = serial_number
out_dict['code_info_group'] = tmp_dict
except:
msg = 'Error parsing output of KKRimp: Version Info'
msg_list.append(msg)
if debug:
traceback.print_exc()
tmp_dict = {
} # used to group convergence info (rms, rms per atom, charge neutrality)
# also initialize convegence_group where all info stored for all iterations is kept
out_dict['convergence_group'] = tmp_dict
try:
rms_charge, rms_spin, result_atoms_last_charge, result_atoms_last_spin = get_rms(
files['outfile'], files['out_log'], debug=debug)
tmp_dict['rms'] = rms_charge[-1]
tmp_dict['rms_all_iterations'] = rms_charge
tmp_dict['rms_per_atom'] = result_atoms_last_charge
if len(rms_spin) > 0:
tmp_dict['rms_spin'] = rms_spin[-1]
else:
tmp_dict['rms_spin'] = None
tmp_dict['rms_spin_all_iterations'] = rms_spin
tmp_dict['rms_spin_per_atom'] = result_atoms_last_spin
tmp_dict['rms_unit'] = 'unitless'
out_dict['convergence_group'] = tmp_dict
except:
msg = 'Error parsing output of KKRimp: rms-error'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
nspin = self._get_nspin(files['out_log'])
natom = self._get_natom(files['out_log'])
newsosol = self._get_newsosol(files['out_log'])
out_dict['nspin'] = nspin
out_dict['number_of_atoms_in_unit_cell'] = natom
out_dict['use_newsosol'] = newsosol
except:
msg = 'Error parsing output of KKRimp: nspin/natom'
msg_list.append(msg)
if debug:
traceback.print_exc()
tmp_dict = {
} # used to group magnetism info (spin and orbital moments)
try:
result = self._get_magtot(files['out_log'], natom, debug=debug)
if len(result) > 0:
tmp_dict['total_spin_moment'] = result[-1]
out_dict['convergence_group'][
'total_spin_moment_all_iterations'] = result
tmp_dict['total_spin_moment_unit'] = 'mu_Bohr'
out_dict['magnetism_group'] = tmp_dict
except:
msg = 'Error parsing output of KKRimp: total magnetic moment'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
if nspin > 1 and newsosol:
#result, vec, angles = get_spinmom_per_atom(outfile, natom, nonco_out_file)
spinmom_atom, spinmom_atom_vec_all_iter, spin_tot_abs = self._get_spinmom_per_atom(
files['out_spinmoms'], natom)
if len(result) > 0:
tmp_dict['total_abs_spin_moment'] = spin_tot_abs
tmp_dict['spin_moment_per_atom'] = spinmom_atom
out_dict['convergence_group'][
'spin_moment_per_atom_all_iterations'] = spinmom_atom_vec_all_iter
tmp_dict['spin_moment_unit'] = 'mu_Bohr'
out_dict['magnetism_group'] = tmp_dict
except:
msg = 'Error parsing output of KKRimp: spin moment per atom'
msg_list.append(msg)
if debug:
traceback.print_exc()
# add orbital moments to magnetis group in parser output
try:
if nspin > 1 and newsosol:
orbmom_atom, orbmom_atom_all_iter = self._get_orbmom_per_atom(
files['out_orbmoms'], natom)
if len(result) > 0:
tmp_dict['total_orbital_moment'] = sum(orbmom_atom)
tmp_dict['orbital_moment_per_atom'] = orbmom_atom
out_dict['convergence_group'][
'orbital_moment_per_atom_all_iterations'] = orbmom_atom_all_iter
tmp_dict['orbital_moment_unit'] = 'mu_Bohr'
out_dict['magnetism_group'] = tmp_dict
except:
msg = 'Error parsing output of KKRimp: orbital moment'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
result = self._get_EF_potfile(files['out_pot'])
out_dict['fermi_energy'] = result
out_dict['fermi_energy_units'] = 'Ry'
except:
msg = 'Error parsing output of KKRimp: EF'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
result = self._get_Etot(files['out_log'])
out_dict['energy'] = result[-1] * get_Ry2eV()
out_dict['energy_unit'] = 'eV'
out_dict['total_energy_Ry'] = result[-1]
out_dict['total_energy_Ry_unit'] = 'Rydberg'
out_dict['convergence_group'][
'total_energy_Ry_all_iterations'] = result
except:
msg = 'Error parsing output of KKRimp: total energy'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
result = find_warnings(files['outfile'])
tmp_dict = {}
tmp_dict['number_of_warnings'] = len(result)
tmp_dict['warnings_list'] = result
out_dict['warnings_group'] = tmp_dict
except:
msg = 'Error parsing output of KKRimp: search for warnings'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
result = self._extract_timings(files['out_timing'])
out_dict['timings_group'] = result
out_dict['timings_unit'] = 'seconds'
except:
msg = 'Error parsing output of KKRimp: timings'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
esp_at, etot_at = self._get_energies_atom(files['out_enersp_at'],
files['out_enertot_at'],
natom)
out_dict['single_particle_energies'] = esp_at * get_Ry2eV()
out_dict['single_particle_energies_unit'] = 'eV'
out_dict['total_energies_atom'] = etot_at * get_Ry2eV()
out_dict['total_energies_atom_unit'] = 'eV'
except:
msg = 'Error parsing output of KKRimp: single particle energies'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
result_WS, result_tot, result_C = get_charges_per_atom(
files['out_log'])
niter = len(out_dict['convergence_group']['rms_all_iterations'])
natyp = int(len(result_tot) / niter)
out_dict['total_charge_per_atom'] = result_WS[-natyp:]
out_dict['charge_core_states_per_atom'] = result_C[-natyp:]
# this check deals with the DOS case where output is slightly different
if len(result_WS) == len(result_C):
out_dict['charge_valence_states_per_atom'] = result_WS[
-natyp:] - result_C[-natyp:]
out_dict['total_charge_per_atom_unit'] = 'electron charge'
out_dict['charge_core_states_per_atom_unit'] = 'electron charge'
out_dict['charge_valence_states_per_atom_unit'] = 'electron charge'
except:
msg = 'Error parsing output of KKRimp: charges'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
econt = self._get_econt_info(files['out_log'])
tmp_dict = {}
tmp_dict['emin'] = econt.get('emin')
tmp_dict['emin_unit'] = 'Rydberg'
tmp_dict['number_of_energy_points'] = econt.get('Nepts')
tmp_dict['epoints_contour'] = econt.get('epts')
tmp_dict['epoints_contour_unit'] = 'Rydberg'
tmp_dict['epoints_weights'] = econt.get('weights')
out_dict['energy_contour_group'] = tmp_dict
except:
msg = 'Error parsing output of KKRimp: energy contour'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
ncore, emax, lmax, descr_max = get_core_states(files['out_pot'])
tmp_dict = {}
tmp_dict['number_of_core_states_per_atom'] = ncore
tmp_dict['energy_highest_lying_core_state_per_atom'] = emax
tmp_dict[
'energy_highest_lying_core_state_per_atom_unit'] = 'Rydberg'
tmp_dict['descr_highest_lying_core_state_per_atom'] = descr_max
out_dict['core_states_group'] = tmp_dict
except:
msg = 'Error parsing output of KKRimp: core_states'
msg_list.append(msg)
if debug:
traceback.print_exc()
try:
niter, nitermax, converged, nmax_reached, mixinfo = self._get_scfinfo(
files['out_log'])
out_dict['convergence_group']['number_of_iterations'] = niter
out_dict['convergence_group'][
'number_of_iterations_max'] = nitermax
out_dict['convergence_group']['calculation_converged'] = converged
out_dict['convergence_group']['nsteps_exhausted'] = nmax_reached
out_dict['convergence_group']['imix'] = mixinfo[0]
out_dict['convergence_group']['strmix'] = mixinfo[1]
out_dict['convergence_group']['qbound'] = mixinfo[2]
out_dict['convergence_group']['fcm'] = mixinfo[3]
out_dict['convergence_group']['brymix'] = mixinfo[1]
except:
msg = 'Error parsing output of KKRimp: scfinfo'
msg_list.append(msg)
if debug:
traceback.print_exc()
#convert numpy arrays to standard python lists
out_dict = convert_to_pystd(out_dict)
# return output with error messages if there are any
if len(msg_list) > 0:
return False, msg_list, out_dict
else:
return True, [], out_dict
