def test_get_value(self): p = kkrparams(LMAX=3) # check for KeyError if wrong key is checked known_error = False try: p.get_value('something_wrong') except KeyError: known_error = True assert known_error # check for returning unset value npol = p.get_value('NPOL') assert npol == None # check correct LMAX value lmax = p.get_value('LMAX') assert lmax == 3 # check for returning lists for RUNOPT and TESTOPT runopt = p.get_value('RUNOPT') testopt = p.get_value('TESTOPT') assert runopt == [] assert testopt == [] p = kkrparams(TESTOPT=['test1', 'test2'], RUNOPT=['NEWSOSOL']) runopt = p.get_value('RUNOPT') testopt = p.get_value('TESTOPT') assert runopt == ['NEWSOSOL'] assert set(testopt) == set(['test1', 'test2'])
def test_read_unsorted_inputfile(self): p = kkrparams(ZATOM=26., LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], RCLUSTZ=1.5, NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1, RMAX=7, GMAX=65) p.fill_keywords_to_inputfile(output='input.temp.txt') txt = open('input.temp.txt', 'r').readlines() # exchange some lines tmp = txt[0] txt[0] = txt[5] txt[5] = tmp tmp = txt[-1] txt[-1] = txt[-2] txt[-2] = tmp tmp = txt[-2] txt[-2] = txt[-4] txt[-4] = tmp tmp = txt[-3] txt[-3] = txt[-1] txt[-1] = tmp with open('input.temp_unsorted.txt', 'w') as f: f.writelines(txt) p2 = kkrparams() p2.read_keywords_from_inputcard(inputcard='input.temp_unsorted.txt') print(p2.get_dict()) print(dict(p2.get_set_values())) check_full_dict(p, p2)
def test_get_missing_keys(self): p = kkrparams() missing = p.get_missing_keys() assert set(missing) == set( ['<ZATOM>', 'BRAVAIS', 'LMAX', 'GMAX', 'RMAX', 'NAEZ', '<RBASIS>', 'NSPIN', 'ALATBASIS']) missing = p.get_missing_keys(use_aiida=True) assert set(missing) == set(['LMAX', 'GMAX', 'RMAX', 'NSPIN']) p = kkrparams(params_type='voronoi', EMIN=-2, LMAX=3) missing = p.get_missing_keys() assert set(missing) == set(['<ZATOM>', 'BRAVAIS', 'RCLUSTZ', 'NAEZ', '<RBASIS>', 'NSPIN', 'ALATBASIS'])
def test_read_minimal_inputfile(self): p = kkrparams(ZATOM=26., LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], RCLUSTZ=1.5, NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1) p.fill_keywords_to_inputfile(is_voro_calc=True) p2 = kkrparams(params_type='voronoi') p2.read_keywords_from_inputcard() check_full_dict(p, p2)
def test_set_kkrimp_params_full(self, file_regression): p = kkrparams(params_type='kkrimp') p.set_multiple_values(CALCORBITALMOMENT=0, RUNFLAG='', QBOUND=10**-7, NSPIN=1, TESTFLAG='', NPAN_EQ=7, CALCFORCE=0, NPAN_LOGPANELFAC=2, SPINORBIT=0, ITDBRY=20, NPAN_LOG=5, INS=1, ICST=2, CALCJIJMAT=0, NCHEB=10, HFIELD=[0.00, 0], BRYMIX=0.05, KVREL=1, IMIX=0, RADIUS_MIN=-1, NCOLL=0, RADIUS_LOGPANELS=0.6, MIXFAC=0.05, SCFSTEPS=1, XC='LDA-VWN') with tempfile.NamedTemporaryFile('r') as tmp: p.fill_keywords_to_inputfile(output=tmp.name) file_content = tmp.read() file_regression.check(file_content)
def test_get_mandatory(self): p = kkrparams() manlist = p.get_all_mandatory() assert set(manlist) == set([ 'LMAX', 'NAEZ', 'BRAVAIS', 'RMAX', 'GMAX', 'NSPIN', '<RBASIS>', 'ALATBASIS', '<ZATOM>' ])
def _check_and_extract_input_nodes(self, tempfolder): """ Extract input nodes from inputdict and check consitency of input nodes :param inputdict: dict of inputnodes :returns: * parameters (aiida_kkr.tools.kkr_params.kkrparams), optional: parameters of KKRimp that end up in config.cfg * code (KKRimpCodeNode): code of KKRimp on some machine * imp_info (DictNode): parameter node of the impurity information, extracted from host_parent_calc * kkrflex_file_paths (dict): dictionary of {filenames: absolute_path_to_file} for the kkrflex-files * shapfun_path (str): absolute path of the shapefunction of the host parent calculation * host_parent_calc (KkrCalculation): node of the parent host calculation where the kkrflex-files were created * impurity_potential (SinglefileData): single file data node containing the starting potential for the impurity calculation * parent_calc_folder (RemoteData): remote directory of a parent KKRimp calculation """ # get mandatory input nodes (extract code) code = self.inputs.code # now check for optional nodes if 'parameters' in self.inputs: parameters = self.inputs.parameters else: parameters = None if parameters is not None: # convert to kkrparams instance parameters = kkrparams(params_type='kkrimp', **parameters.get_dict()) # get hostfiles imp_info, kkrflex_file_paths, shapfun_path, shapes, host_parent_calc, params_host, structure = self._get_and_verify_hostfiles( tempfolder) # check impurity potential or parent calculation input # impurity_potential if 'impurity_potential' in self.inputs: impurity_potential = self.inputs.impurity_potential found_imp_pot = True else: impurity_potential = None found_imp_pot = False # parent calculation folder if 'parent_calc_folder' in self.inputs: parent_calc_folder = self.inputs.parent_calc_folder found_parent_calc = True else: parent_calc_folder = None found_parent_calc = False # consistency checks if not found_parent_calc and not found_imp_pot: raise InputValidationError( "Neither impurity_potential nor parent_calc_folder specified for this calculation.\n" "Please provide either impurity_potential or parent_calc_folder." ) elif found_parent_calc and found_imp_pot: raise InputValidationError( "Both impurity_potential and parent_calc_folder specified for this calculation.\n" "Please provide one one, i.e. either impurity_potential or parent_calc_folder." ) # Done checking inputs, returning... return parameters, code, imp_info, kkrflex_file_paths, shapfun_path, shapes, host_parent_calc, params_host, impurity_potential, parent_calc_folder, structure
def test_fill_inputfile_minimal_Voronoi(self): p = kkrparams(ZATOM=29., LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], RCLUSTZ=1.5, NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1) p.fill_keywords_to_inputfile(is_voro_calc=True) txt = open('inputcard').readlines() ref = [ 'ALATBASIS= 1.00000000000000\n', 'BRAVAIS\n', '1.00000000000000 0.00000000000000 0.00000000000000\n', '0.00000000000000 1.00000000000000 0.00000000000000\n', '0.00000000000000 0.00000000000000 1.00000000000000\n', 'NAEZ= 1\n', '<RBASIS>\n', '0.00000000000000 0.00000000000000 0.00000000000000\n', '<ZATOM>\n', '29.00000000000000\n', 'NSPIN= 2\n', 'LMAX= 2\n', 'RCLUSTZ= 1.50000000000000\n' ] done = False while not done: try: txt.remove('\n') except ValueError: done = True assert len(txt) == len(ref) txt.sort() ref.sort() print(txt, ref) for i in range(len(txt)): print(i, txt[i], ref[i]) assert set(txt[i].split()) == set(ref[i].split())
def test_read_slab(self, data_regression): from numpy import array, ndarray from masci_tools.io.common_functions import get_aBohr2Ang p = kkrparams(params_type='kkr') # automatically read keywords from inpucard p.read_keywords_from_inputcard(inputcard='../tests/files/kkr/import_calc_old_style/inputcard') # convert some read-in stuff back from Ang. units to alat units rbl = p.get_value('<RBLEFT>') rbr = p.get_value('<RBRIGHT>') zper_l = p.get_value('ZPERIODL') zper_r = p.get_value('ZPERIODR') ang2alat = 1 / (p.get_value('ALATBASIS') * get_aBohr2Ang()) if rbl is not None: p.set_value('<RBLEFT>', array(rbl) * ang2alat) if rbr is not None: p.set_value('<RBRIGHT>', array(rbr) * ang2alat) if zper_l is not None: p.set_value('ZPERIODL', array(zper_l) * ang2alat) if zper_r is not None: p.set_value('ZPERIODR', array(zper_r) * ang2alat) # check all values, replace arrays by lists to make data-regression work d_check = p.get_dict() for k, v in d_check.items(): if type(v) == ndarray: d_check[k] = v.tolist() data_regression.check(d_check)
def test_set_rmtcore(self): #test rmtcore from numpy import array from masci_tools.io.common_functions import search_string para_dict = dict([ (u'INS', 0), (u'RCLUSTZ', 1.69), (u'LMAX', 2), (u'GMAX', 65.0), (u'<RMTCORE>', [0.3535533906, 0.3535533906, 0.3535533906, 0.3535533906]), (u'RMAX', 7.0), (u'NSPIN', 1) ]) zatom = array([47., 47., 47., 47.]) alat = 7.8692316414074615 natom = 4 positions = array([[0., 0., 0.], [0., 0.5, 0.5], [0.5, 0., 0.5], [0.5, 0.5, 0.]]) bravais = array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]) k = kkrparams(**para_dict) k.set_multiple_values(ZATOM=zatom, NAEZ=natom, ALATBASIS=alat, RBASIS=positions, BRAVAIS=bravais) k.fill_keywords_to_inputfile() txt = open('inputcard').readlines() naez = int(txt[search_string('NAEZ', txt)].split()[-1]) rmtcore = [] l_offset = search_string('RMTCORE', txt) for iatom in range(naez): rmtcore_at = float(txt[l_offset + 1 + iatom].split()[-1]) rmtcore.append(rmtcore_at) maxdiff = (max(abs(array(para_dict['<RMTCORE>']) - array(rmtcore)))) assert maxdiff < 10**-6
def test_fill_inputfile_KKR(self): reffile = [ 'ALATBASIS= 1.00000000000000\n', 'BRAVAIS\n', '1.00000000000000 0.00000000000000 0.00000000000000\n', '<ZATOM>\n', '29.00000000000000\n', '0.00000000000000 1.00000000000000 0.00000000000000\n', '0.00000000000000 0.00000000000000 1.00000000000000\n', 'NAEZ= 1\n', '<RBASIS>\n', '0.00000000000000 0.00000000000000 0.00000000000000\n', 'NSPIN= 2\n', 'LMAX= 2\n', 'RCLUSTZ= 1.50000000000000\n', 'RMAX= 7.00000000000000\n', 'GMAX= 65.00000000000000\n' ] p = kkrparams(ZATOM=29., LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], RMAX=7, GMAX=65, RCLUSTZ=1.5, NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1) p.fill_keywords_to_inputfile() txt = open('inputcard').readlines() done = False while not done: try: txt.remove('\n') except ValueError: done = True assert len(txt) == len(reffile) txt.sort() reffile.sort() for i in range(len(txt)): assert set(txt[i].split()) == set(reffile[i].split())
def test_wrong_input_type(self): p = kkrparams() with pytest.raises(TypeError): p.set_value('EMIN', '2') with pytest.raises(TypeError): p.set_value('EMIN', False)
def test_get_set_values2(self): from numpy import array p = kkrparams() p.set_multiple_values(EMIN=1, EMAX=2) setlist = p.get_set_values() assert set(array(setlist).flatten()) == set( array([['EMIN', 1.], ['EMAX', 2.]]).flatten())
def test_fill_inputfile_empty_check(self): p = kkrparams(LMAX=2, NAEZ=1) known_error = False try: p.fill_keywords_to_inputfile() except ValueError: known_error = True assert known_error
def test_read_minimal_inputfile(self): p = kkrparams(ZATOM=26., LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], RCLUSTZ=1.5, NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1) cwd = os.getcwd() with tempfile.TemporaryDirectory() as td: os.chdir(td) p.fill_keywords_to_inputfile(is_voro_calc=True) p2 = kkrparams(params_type='voronoi') p2.read_keywords_from_inputcard() os.chdir(cwd) check_full_dict(p, p2)
def test_set_value_None(self): p = kkrparams() p.set_value('EMIN', -1) assert p.values['EMIN'] == -1 p.set_value('EMIN', None) assert p.values['EMIN'] == -1 p.remove_value('EMIN') assert p.values['EMIN'] is None
def test_startpot_Cu_simple(self): """ simple Cu noSOC, FP, lmax2 full example """ from aiida.orm import Code from aiida.plugins import DataFactory from masci_tools.io.kkr_params import kkrparams from aiida_kkr.calculations.voro import VoronoiCalculation Dict = DataFactory('dict') StructureData = DataFactory('structure') # create StructureData instance for Cu alat = 3.61 # lattice constant in Angstroem bravais = [[0.5 * alat, 0.5 * alat, 0], [0.5 * alat, 0, 0.5 * alat], [0, 0.5 * alat, 0.5 * alat]] # Bravais matrix in Ang. units Cu = StructureData(cell=bravais) Cu.append_atom(position=[0, 0, 0], symbols='Cu') # create Dict input node using kkrparams class from masci-tools params = kkrparams(params_type='voronoi') params.set_multiple_values(LMAX=2, NSPIN=1, RCLUSTZ=2.3) Dict = DataFactory( 'dict') # use DataFactory to get ParamerterData class ParaNode = Dict(dict=params.get_dict()) # import computer etc from database dump from aiida.tools.importexport import import_data import_data('files/db_dump_vorocalc.tar.gz') # prepare computer and code (needed so that prepare_code(voro_codename, codelocation, computername, workdir) # load code from database and create new voronoi calculation #code = Code.get_from_string(codename) code = Code.get_from_string(voro_codename + '@' + computername) #code = Code.get_from_string('voronoi@localhost_new') options = { 'resources': { 'num_machines': 1, 'tot_num_mpiprocs': 1 }, 'queue_name': queuename } builder = VoronoiCalculation.get_builder() builder.code = code builder.metadata.options = options builder.parameters = ParaNode builder.structure = Cu builder.metadata.dry_run = True from aiida.engine import run run(builder)
def test_inconsistency_bulk_mode_bravais(self): p = kkrparams(LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 0]], NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1, RMAX=7, GMAX=65, ZATOM=29.) with pytest.raises(ValueError): p.fill_keywords_to_inputfile()
def test_get_value(self): p = kkrparams(LMAX=3) # check for KeyError if wrong key is checked with pytest.raises(KeyError): p.get_value('something_wrong') # check for returning unset value npol = p.get_value('NPOL') assert npol is None # check correct LMAX value lmax = p.get_value('LMAX') assert lmax == 3 # check for returning lists for RUNOPT and TESTOPT runopt = p.get_value('RUNOPT') testopt = p.get_value('TESTOPT') assert runopt == [] assert testopt == [] p = kkrparams(TESTOPT=['test1', 'test2'], RUNOPT=['NEWSOSOL']) runopt = p.get_value('RUNOPT') testopt = p.get_value('TESTOPT') assert runopt == ['NEWSOSOL'] assert set(testopt) == set(['test1', 'test2'])
def test_input_consistency_check_fail(self): p = kkrparams(ZATOM=29., LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], RMAX=7, GMAX=65, NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1) p.set_value('LDAU_PARA', [1, 2]) with pytest.raises(TypeError): p._check_input_consistency()
def test_wrong_input_type(self): p = kkrparams() known_error = False try: p.set_value('EMIN', '2') except TypeError: known_error = True assert known_error known_error = False try: p.set_value('EMIN', False) except TypeError: known_error = True assert known_error
def test_wrong_input_array_dimension(self): p = kkrparams() from numpy import array, sqrt bravais = array([[0.7071067812, -0.5, 0.0], [0.7071067812, 0.5, 0.0], [sqrt(2), 0.0, 0.866025404]]) # atom positions in relative coordinates basis_vectors = [] for iatom in range(6): tmp = array([0, 0, 0]) + iatom * array([0.5, 0.5, bravais[2, 2]]) tmp[0] = tmp[0] % 1 tmp[1] = tmp[1] % 1 print(iatom, tmp) basis_vectors.append(tmp) basis_vectors = array(basis_vectors) p.set_value('INTERFACE', True) p.set_value('<RBLEFT>', array([[1, 1], [0, 1]]))
def test_inconsistency_bulk_mode_bravais(self): p = kkrparams(LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 0]], NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1, RMAX=7, GMAX=65, ZATOM=29.) knownError = False try: p.fill_keywords_to_inputfile() except ValueError: knownError = True assert knownError
def test_fill_inputfile_minimal_Voronoi(self, file_regression): p = kkrparams(ZATOM=29., LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], RCLUSTZ=1.5, NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1) cwd = os.getcwd() with tempfile.TemporaryDirectory() as td: os.chdir(td) p.fill_keywords_to_inputfile(is_voro_calc=True) file_content = open('inputcard').read() os.chdir(cwd) file_regression.check(file_content)
def test_input_consistency_check_fail(self): knownError = False try: p = kkrparams(ZATOM=29., LMAX=2, NAEZ=1, BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], RMAX=7, GMAX=65, NSPIN=2, RBASIS=[0, 0, 0], ALATBASIS=1) p.set_value('LDAU_PARA', [1, 2]) p._check_input_consistency() except TypeError: knownError = True assert knownError
def test_host_in_host(self): """ simple Cu noSOC, FP, lmax2 """ from aiida.orm import Code, load_node from aiida.plugins import DataFactory from masci_tools.io.kkr_params import kkrparams from aiida_kkr.calculations.kkrimp import KkrimpCalculation Dict = DataFactory('dict') # first load parent voronoi calculation from aiida.tools.importexport import import_data import_data('files/db_dump_kkrflex_create.tar.gz') GF_host_calc = load_node('baabef05-f418-4475-bba5-ef0ee3fd5ca6') # prepare computer and code (needed so that prepare_code(kkrimp_codename, codelocation, computername, workdir) # now create a SingleFileData node containing the impurity starting potential from aiida_kkr.tools.common_workfunctions import neworder_potential_wf from numpy import loadtxt neworder_pot1 = [int(i) for i in loadtxt(GF_host_calc.outputs.retrieved.open('scoef'), skiprows=1)[:,3]-1] settings_dict = {'pot1': 'out_potential', 'out_pot': 'potential_imp', 'neworder': neworder_pot1} settings = Dict(dict=settings_dict) startpot_imp_sfd = neworder_potential_wf(settings_node=settings, parent_calc_folder=GF_host_calc.outputs.remote_folder) # set 1 simple mixing step kkrimp_params = kkrparams(params_type='kkrimp') kkrimp_params.set_multiple_values(SCFSTEPS=1, IMIX=0, MIXFAC=0.05) ParamsKKRimp = Dict(dict=kkrimp_params.get_dict()) # create new KKRimp calculation #kkrimp_code = Code.get_from_string(codename) kkrimp_code = Code.get_from_string(kkrimp_codename+'@'+computername) options = {'resources': {'num_machines':1, 'tot_num_mpiprocs':1}, 'queue_name': queuename} builder = KkrimpCalculation.get_builder() builder.code = kkrimp_code builder.host_Greenfunction_folder = GF_host_calc.outputs.remote_folder builder.impurity_potential = startpot_imp_sfd builder.metadata.options = options builder.parameters = ParamsKKRimp builder.metadata.dry_run = True from aiida.engine import run run(builder)
def test_update_params_wf(self): from aiida_kkr.tools.common_workfunctions import update_params_wf from masci_tools.io.kkr_params import kkrparams from aiida.plugins import DataFactory Dict = DataFactory('dict') k = kkrparams(LMAX=2) node1 = Dict(dict=k.values) node2 = Dict( dict={ 'nodename': 'my_changed_name', 'nodedesc': 'My description text', 'EMIN': -1, 'RMAX': 10. }) unode = update_params_wf(node1, node1) assert unode.get_dict() == node1.get_dict() unode = update_params_wf(node1, node2) d0 = node1.get_dict() for i in list(d0.keys()): if d0[i] is None: d0.pop(i) d1 = unode.get_dict() for i in list(d1.keys()): if d1[i] is None: d1.pop(i) l_identical, l_diff = [], [] for i in list(d0.keys()): if i in list(d1.keys()): l_identical.append([i, d0[i], d1[i]]) else: l_diff.append([0, i, d0[i]]) for i in list(d1.keys()): if i not in list(d0.keys()): l_diff.append([1, i, d1[i]]) assert l_identical == [[u'LMAX', 2, 2]] assert l_diff.sort() == [[1, u'RMAX', 10.0], [1, u'EMIN', -1.0]].sort() return node1, node2, unode
def test_fill_inputfile_filehandle(self): p = kkrparams(params_type='kkrimp') p.set_multiple_values(CALCORBITALMOMENT=0, RUNFLAG='', QBOUND=10**-7, NSPIN=1, TESTFLAG='', NPAN_EQ=7, CALCFORCE=0, NPAN_LOGPANELFAC=2, SPINORBIT=0, ITDBRY=20, NPAN_LOG=5, INS=1, ICST=2, CALCJIJMAT=0, NCHEB=10, HFIELD=[0.00, 0], BRYMIX=0.05, KVREL=1, IMIX=0, RADIUS_MIN=-1, NCOLL=0, RADIUS_LOGPANELS=0.6, MIXFAC=0.05, SCFSTEPS=1, XC='LDA-VWN') out_fhandle = open_general('config.cfg', 'w') p.fill_keywords_to_inputfile(output=out_fhandle) reftxt = [ 'RUNFLAG=\n', 'TESTFLAG=\n', '\n', 'INS= 1\n', 'KVREL= 1\n', 'NSPIN= 1\n', '\n', 'SCFSTEPS= 1\n', 'IMIX= 0\n', 'ITDBRY= 20\n', 'MIXFAC= 0.05000000000000\n', 'BRYMIX= 0.05000000000000\n', 'QBOUND= 1.000000e-07\n', '\n', 'XC= LDA-VWN\n', 'ICST= 2\n', 'SPINORBIT= 0\n', 'NCOLL= 0\n', 'NPAN_LOGPANELFAC= 2\n', 'RADIUS_LOGPANELS= 0.60000000000000\n', 'RADIUS_MIN= -1\n', 'NPAN_LOG= 5\n', 'NPAN_EQ= 7\n', 'NCHEB= 10\n', '\n', 'HFIELD= 0.00000000000000 0\n', '\n', 'CALCORBITALMOMENT= 0\n', 'CALCFORCE= 0\n', 'CALCJIJMAT= 0\n' ] txt = open('config.cfg').readlines() assert txt == reftxt
def check_voro_out(self): """ check outout of vorostart workflow and create input for rest of calculations (rmtcore setting etc.) """ self.report('INFO: checking voronoi output') # get output of kkr_startpot out_wc = self.ctx.kkr_startpot try: res = out_wc.outputs.results_vorostart_wc voro_params = out_wc.outputs.last_params_voronoi smallest_voro_remote = out_wc.outputs.last_voronoi_remote smallest_voro_results = out_wc.outputs.last_voronoi_results vorostart_success = res.get_dict()['successful'] except: vorostart_success = False if vorostart_success: rmt = [] radii = smallest_voro_results.get_dict()['radii_atoms_group'] for rad_iatom in radii: if 'rmt0' in list(rad_iatom.keys()): rmt.append(rad_iatom['rmt0']) rmtcore_min = array(rmt) * smallest_voro_results.get_dict().get( 'alat') # needs to be mutiplied by alat in atomic units! self.report('INFO: extracted rmtcore_min ({})'.format(rmtcore_min)) else: return self.exit_codes.ERROR_VOROSTART_NOT_SUCCESSFUL # update parameter node with rmtcore setting voro_params_with_rmtcore = kkrparams(**voro_params.get_dict()) voro_params_with_rmtcore.set_value('<RMTCORE>', rmtcore_min) voro_params_with_rmtcore_dict = voro_params_with_rmtcore.get_dict() voro_params_with_rmtcore = update_params_wf( voro_params, Dict(dict=voro_params_with_rmtcore_dict)) self.report( 'INFO: updated kkr_parameters inlcuding RMTCORE setting (uuid={})'. format(voro_params_with_rmtcore.uuid)) # store links to context self.ctx.params_kkr_run = voro_params_with_rmtcore self.ctx.smallest_voro_remote = smallest_voro_remote
def test_set_potname_empty(self): p = kkrparams() p.set_multiple_values(RMAX=1, GMAX=1, NSPIN=1, RBASIS=[0, 0, 0], LMAX=2, RCLUSTZ=1.2, NAEZ=1, ZATOM=[0], BRAVAIS=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], ALATBASIS=1, FILES=['', 'shapenew']) p.fill_keywords_to_inputfile() from masci_tools.io.common_functions import search_string txt = open('inputcard').readlines() itmp = search_string('FILES', txt) potname = txt[itmp + 2].split()[0] shapename = txt[itmp + 4].split()[0] assert 'potential' == potname assert 'shapenew' == shapename