def get_lapw_calculation(self, lapw_structure, lapw_parameters, lapw_kpoint): params = self.get_parameters() lapw_codename = params['lapw_codename'] num_machines = params['num_machines'] max_wallclock_seconds = params['max_wallclock_seconds'] lapwbasis_family = params['lapwbasis_family'] code = Code.get_from_string(lapw_codename) computer = code.get_remote_computer() LAPWCalc = CalculationFactory('exciting.exciting') calc = LAPWCalc(computer=computer) calc.set_max_wallclock_seconds(max_wallclock_seconds) calc.set_resources({"num_machines": num_machines}) calc.store() calc.use_code(code) calc.use_structure(lapw_structure) calc.use_lapwbasis_from_family(lapwbasis_family) calc.use_parameters(lapw_parameters) calc.use_kpoints(lapw_kpoint) return calc
def get_pw_calculation(self, pw_structure, pw_parameters, pw_kpoint): params = self.get_parameters() pw_codename = params['pw_codename'] num_machines = params['num_machines'] max_wallclock_seconds = params['max_wallclock_seconds'] pseudo_family = params['pseudo_family'] code = Code.get_from_string(pw_codename) computer = code.get_remote_computer() QECalc = CalculationFactory('quantumespresso.pw') calc = QECalc(computer=computer) calc.set_max_wallclock_seconds(max_wallclock_seconds) calc.set_resources({"num_machines": num_machines}) calc.store() calc.use_code(code) calc.use_structure(pw_structure) calc.use_pseudos_from_family(pseudo_family) calc.use_parameters(pw_parameters) calc.use_kpoints(pw_kpoint) return calc
def test_autogroup_filter_class(self): # pylint: disable=too-many-locals """Check if the autogroup is properly generated but filtered classes are skipped.""" from aiida.orm import Code, QueryBuilder, Node, AutoGroup, load_node script_content = textwrap.dedent("""\ import sys from aiida.orm import Computer, Int, ArrayData, KpointsData, CalculationNode, WorkflowNode from aiida.plugins import CalculationFactory from aiida.engine import run_get_node ArithmeticAdd = CalculationFactory('arithmetic.add') computer = Computer( label='localhost-example-{}'.format(sys.argv[1]), hostname='localhost', description='my computer', transport_type='local', scheduler_type='direct', workdir='/tmp' ).store() computer.configure() code = Code( input_plugin_name='arithmetic.add', remote_computer_exec=[computer, '/bin/true']).store() inputs = { 'x': Int(1), 'y': Int(2), 'code': code, 'metadata': { 'options': { 'resources': { 'num_machines': 1, 'num_mpiprocs_per_machine': 1 } } } } node1 = KpointsData().store() node2 = ArrayData().store() node3 = Int(3).store() node4 = CalculationNode().store() node5 = WorkflowNode().store() _, node6 = run_get_node(ArithmeticAdd, **inputs) print(node1.pk) print(node2.pk) print(node3.pk) print(node4.pk) print(node5.pk) print(node6.pk) """) Code() for idx, ( flags, kptdata_in_autogroup, arraydata_in_autogroup, int_in_autogroup, calc_in_autogroup, wf_in_autogroup, calcarithmetic_in_autogroup, ) in enumerate([ [['--exclude', 'aiida.data:array.kpoints'], False, True, True, True, True, True], # Check if % works anywhere - both 'int' and 'array.kpoints' contain an 'i' [['--exclude', 'aiida.data:%i%'], False, True, False, True, True, True], [['--exclude', 'aiida.data:int'], True, True, False, True, True, True], [['--exclude', 'aiida.data:%'], False, False, False, True, True, True], [['--exclude', 'aiida.data:array', 'aiida.data:array.%'], False, False, True, True, True, True], [[ '--exclude', 'aiida.data:array', 'aiida.data:array.%', 'aiida.data:int' ], False, False, False, True, True, True], [['--exclude', 'aiida.calculations:arithmetic.add'], True, True, True, True, True, False], [ ['--include', 'aiida.node:process.calculation' ], # Base type, no specific plugin False, False, False, True, False, False ], [ ['--include', 'aiida.node:process.workflow' ], # Base type, no specific plugin False, False, False, False, True, False ], [[], True, True, True, True, True, True], ]): with tempfile.NamedTemporaryFile(mode='w+') as fhandle: fhandle.write(script_content) fhandle.flush() options = ['--auto-group'] + flags + [ '--', fhandle.name, str(idx) ] result = self.cli_runner.invoke(cmd_run.run, options) self.assertClickResultNoException(result) pk1_str, pk2_str, pk3_str, pk4_str, pk5_str, pk6_str = result.output.split( ) pk1 = int(pk1_str) pk2 = int(pk2_str) pk3 = int(pk3_str) pk4 = int(pk4_str) pk5 = int(pk5_str) pk6 = int(pk6_str) _ = load_node(pk1) # Check if the node can be loaded _ = load_node(pk2) # Check if the node can be loaded _ = load_node(pk3) # Check if the node can be loaded _ = load_node(pk4) # Check if the node can be loaded _ = load_node(pk5) # Check if the node can be loaded _ = load_node(pk6) # Check if the node can be loaded queryb = QueryBuilder().append(Node, filters={'id': pk1}, tag='node') queryb.append(AutoGroup, with_node='node', project='*') all_auto_groups_kptdata = queryb.all() queryb = QueryBuilder().append(Node, filters={'id': pk2}, tag='node') queryb.append(AutoGroup, with_node='node', project='*') all_auto_groups_arraydata = queryb.all() queryb = QueryBuilder().append(Node, filters={'id': pk3}, tag='node') queryb.append(AutoGroup, with_node='node', project='*') all_auto_groups_int = queryb.all() queryb = QueryBuilder().append(Node, filters={'id': pk4}, tag='node') queryb.append(AutoGroup, with_node='node', project='*') all_auto_groups_calc = queryb.all() queryb = QueryBuilder().append(Node, filters={'id': pk5}, tag='node') queryb.append(AutoGroup, with_node='node', project='*') all_auto_groups_wf = queryb.all() queryb = QueryBuilder().append(Node, filters={'id': pk6}, tag='node') queryb.append(AutoGroup, with_node='node', project='*') all_auto_groups_calcarithmetic = queryb.all() self.assertEqual( len(all_auto_groups_kptdata), 1 if kptdata_in_autogroup else 0, 'Wrong number of nodes in autogroup associated with the KpointsData node ' "just created with flags '{}'".format(' '.join(flags))) self.assertEqual( len(all_auto_groups_arraydata), 1 if arraydata_in_autogroup else 0, 'Wrong number of nodes in autogroup associated with the ArrayData node ' "just created with flags '{}'".format(' '.join(flags))) self.assertEqual( len(all_auto_groups_int), 1 if int_in_autogroup else 0, 'Wrong number of nodes in autogroup associated with the Int node ' "just created with flags '{}'".format(' '.join(flags))) self.assertEqual( len(all_auto_groups_calc), 1 if calc_in_autogroup else 0, 'Wrong number of nodes in autogroup associated with the CalculationNode ' "just created with flags '{}'".format(' '.join(flags))) self.assertEqual( len(all_auto_groups_wf), 1 if wf_in_autogroup else 0, 'Wrong number of nodes in autogroup associated with the WorkflowNode ' "just created with flags '{}'".format(' '.join(flags))) self.assertEqual( len(all_auto_groups_calcarithmetic), 1 if calcarithmetic_in_autogroup else 0, 'Wrong number of nodes in autogroup associated with the ArithmeticAdd CalcJobNode ' "just created with flags '{}'".format(' '.join(flags)))
VaspCalculation = CalculationFactory('vasp.vasp') options = { 'resources': { 'num_machines': 1, 'tot_num_mpiprocs': 1, }, 'max_wallclock_seconds': 1800, } kpoints = KpointsData() kpoints.set_kpoints_mesh([1, 1, 1]) inputs = { 'code': Code.get_from_string('VASP.5.4.4@Raichu'), 'structure': load_node(888), 'kpoints': kpoints, 'parameters': ParameterData(dict={}), 'settings': ParameterData(dict={}), 'pseudo_family': Str('vasp-pbe'), 'options' : ParameterData( dict = { 'max_wallclock_seconds' : 3600, 'max_memory_kb': 10000000, 'resources' : { 'num_machines': 1 }, }), 'max_iterations' : Int(1), } process = VaspCalculation.process()
def test_code_local(self): """Test local code.""" import tempfile from aiida.orm import Code from aiida.common.exceptions import ValidationError code = Code(local_executable='test.sh') with self.assertRaises(ValidationError): # No file with name test.sh code.store() with tempfile.NamedTemporaryFile(mode='w+') as fhandle: fhandle.write('#/bin/bash\n\necho test run\n') fhandle.flush() code.put_object_from_filelike(fhandle, 'test.sh') code.store() self.assertTrue(code.can_run_on(self.computer)) self.assertTrue(code.get_local_executable(), 'test.sh') self.assertTrue(code.get_execname(), 'stest.sh')
type=float, help='time in minutes') args = parser.parse_args() sirius_config_fname = 'sirius.json' assert os.path.exists(sirius_config_fname) assert os.path.exists('nlcg.yaml') # converters sirius_json to aiida provenance input sirius_json = json.load(open(sirius_config_fname, 'r')) # get code computer = helpers.get_computer('localhost') # code = helpers.get_code(entry_point='sirius.py.nlcg', computer=computer) code = Code.get_from_string('sirius.py.nlcg@' + computer.get_name()) #################### # # Prepare inputs # #################### SiriusParameters = DataFactory('sirius.scf') StructureData = DataFactory('structure') KpointsData = DataFactory('array.kpoints') Dict = DataFactory('dict') SinglefileData = DataFactory('singlefile') NLCGParameters = DataFactory('sirius.py.nlcg') parameters = SiriusParameters(sirius_json) nlcgconfig = yaml.load(open('nlcg.yaml', 'r')) nlcgconfig = {'System': nlcgconfig['System'], 'CG': nlcgconfig['CG']}
def main(zeopp_code_label, raspa_code_label): """ Prepare inputs and submit the Isotherm workchain. Usage: verdi run run_HTSEvWorkChain_KAXQIL_2comp.py zeopp@teslin raspa37@teslin """ builder = HTSEvWorkChain.get_builder() builder.metadata.label = "test_ev" builder.structure = CifData( file=os.path.abspath('../aiida_matdis/data/KAXQIL_clean_P1.cif'), label="kaxqil") builder.mixture = Dict( dict={ 'comp1': { 'name': 'xenon', 'molfraction': 0.20 }, 'comp2': { 'name': 'krypton', 'molfraction': 0.80 } }) builder.ev_output = load_node(21064) builder.zeopp.code = Code.get_from_string(zeopp_code_label) builder.zeopp.atomic_radii = SinglefileData( file=os.path.abspath('../aiida_matdis/data/UFF.rad')) builder.raspa_base.raspa.code = Code.get_from_string(raspa_code_label) options = { "resources": { "num_machines": 1, "tot_num_mpiprocs": 1, }, "max_wallclock_seconds": 1 * 60 * 60, "withmpi": False, } builder.raspa_base.raspa.metadata.options = options builder.zeopp.metadata.options = options builder.parameters = Dict( dict={ 'ff_framework': 'UFF', # Default: UFF "ff_cutoff": 12.5, 'temperature': 298, # (K) Note: higher temperature will have less adsorbate and it is faster "ff_tail_corrections": False, 'zeopp_volpo_samples': 1000, # Default: 1e5 *NOTE: default is good for standard real-case! 'zeopp_sa_samples': 1000, # Default: 1e5 *NOTE: default is good for standard real-case! 'zeopp_block_samples': 100, # Default: 100 'raspa_widom_cycles': 500, # Default: 1e5 'raspa_gcmc_init_cycles': 500, # Default: 1e3 'raspa_gcmc_prod_cycles': 500, # Default: 1e4 'pressure_list': [0.1, 1.0], 'probe_based': True, }) run(builder)
def main(cp2k_code_string, ddec_code_string, ddec_atdens_path): """Example usage: ATDENS_PATH='/home/daniele/aiida-lsmo-codes/data/chargemol/atomic_densities/' verdi run run_Cp2kMultistageDdecWorkChain_h2o.py cp2k@localhost ddec@localhost $ATDENS_PATH """ print('Testing CP2K-Multistage calculation + DDEC on H2O...') cp2k_code = Code.get_from_string(cp2k_code_string) ddec_code = Code.get_from_string(ddec_code_string) atoms = ase.build.molecule('H2O') atoms.center(vacuum=2.0) structure = StructureData(ase=atoms) cp2k_options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': 10 * 60, 'withmpi': True, } ddec_options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': 10 * 60, 'withmpi': False, } ddec_params = Dict( dict={ 'net charge': 0.0, 'charge type': 'DDEC6', 'periodicity along A, B, and C vectors': [True, True, True], 'compute BOs': False, 'atomic densities directory complete path': ddec_atdens_path, 'input filename': 'valence_density', }) inputs = { 'structure': structure, 'metadata': { 'label': 'test-h2o' }, 'protocol_tag': Str('test'), 'cp2k_base': { 'cp2k': { 'code': cp2k_code, 'metadata': { 'options': cp2k_options, } } }, 'ddec': { 'parameters': ddec_params, 'code': ddec_code, 'metadata': { 'options': ddec_options, } } } run(MultistageDdecWorkChain, **inputs)
def test_scf_wc_Cu_simple(self): """ simple Cu noSOC, FP, lmax2 full example using scf workflow """ from aiida.orm import Code, load_node, DataFactory from aiida.work import run from aiida_kkr.tools.kkr_params import kkrparams from aiida_kkr.workflows.kkr_scf import kkr_scf_wc from pprint import pprint from scipy import array ParameterData = DataFactory('parameter') StructureData = DataFactory('structure') alat = 6.83 # in a_Bohr abohr = 0.52917721067 # conversion factor to Angstroem units # bravais vectors bravais = array([[0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5]]) a = 0.5 * alat * abohr Cu = StructureData(cell=[[a, a, 0.0], [a, 0.0, a], [0.0, a, a]]) Cu.append_atom(position=[0.0, 0.0, 0.0], symbols='Cu') Cu.store() print(Cu) # here we create a parameter node for the workflow input (workflow specific parameter) and adjust the convergence criterion. wfd = kkr_scf_wc.get_wf_defaults() wfd['convergence_criterion'] = 10**-4 wfd['check_dos'] = False wfd['kkr_runmax'] = 5 wfd['nsteps'] = 50 wfd['queue_name'] = '' wfd['resources']['num_machines'] = 1 wfd['use_mpi'] = False #True wfd['num_rerun'] = 2 wfd['natom_in_cls_min'] = 20 KKRscf_wf_parameters = ParameterData(dict=wfd) # The scf-workflow needs also the voronoi and KKR codes to be able to run the calulations VoroCode = Code.get_from_string('voronoi@my_mac') KKRCode = Code.get_from_string('KKRcode@my_mac') # Finally we use the kkrparams class to prepare a valid set of KKR parameters that are stored as a ParameterData object for the use in aiida ParaNode = ParameterData(dict=kkrparams( LMAX=2, RMAX=7, GMAX=65, NSPIN=1, RCLUSTZ=1.9).get_dict()) label = 'KKR-scf for Cu bulk' descr = 'KKR self-consistency workflow for Cu bulk' try: out = run(kkr_scf_wc, structure=Cu, calc_parameters=ParaNode, voronoi=VoroCode, kkr=KKRCode, wf_parameters=KKRscf_wf_parameters, _label=label, _description=descr) except: print 'some Error occured in run of kkr_scf_wc' # load node of workflow print out n = load_node(out[1]) print '\noutputs of workflow\n-------------------------------------------------' pprint(n.get_outputs_dict()) # get output dictionary n = n.get_outputs()[-1] out = n.get_dict() print '\n\noutput dictionary:\n-------------------------------------------------' pprint(out) # finally check some output print '\n\ncheck values ...\n-------------------------------------------------' print 'voronoi_step_success', out['voronoi_step_success'] assert out['voronoi_step_success'] print 'kkr_step_success', out['kkr_step_success'] assert out['kkr_step_success'] print 'successful', out['successful'] assert out['successful'] print 'error', out['errors'] assert out['errors'] == [] print 'warning', out['warnings'] assert out['warnings'] == [] print 'convergence_reached', out['convergence_reached'] assert out['convergence_reached'] print 'convergence_value', out['convergence_value'] assert out['convergence_value'] < 10**-4 print 'charge_neutrality', abs(out['charge_neutrality']) assert abs(out['charge_neutrality']) < 5 * 10**-4 print 'used_higher_accuracy', out['used_higher_accuracy'] assert out['used_higher_accuracy'] print '\ndone with checks\n'
def setUp(self): self.calc_cls = CalculationFactory('vasp.scf') self.code = Code() self.code.set_computer(self.computer) self.code.set_remote_computer_exec((self.computer, '/bin/foo')) Common.import_paw()
def main(cp2k_code_string, ddec_code_string, ddec_atdens_path): """Example usage: ATDENS_PATH='/home/daniele/Programs/aiida-database/data/chargemol_09_26_2017/atomic_densities/' verdi run run_cp2k_ddec_MOF-74.py cp2k@localhost ddec@localhost $ATDENS_PATH """ print('Testing CP2K ENERGY calculation + DDEC on H2O...') cp2k_code = Code.get_from_string(cp2k_code_string) ddec_code = Code.get_from_string(ddec_code_string) thisdir = os.path.dirname(os.path.abspath(__file__)) structure = StructureData( ase=ase.io.read(os.path.join(thisdir, 'data/Zn-MOF-74.cif'))) cp2k_options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': 10 * 60, 'withmpi': True, } ddec_options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': 10 * 60, 'withmpi': False, } cp2k_params = Dict( dict={ 'FORCE_EVAL': { 'METHOD': 'Quickstep', 'DFT': { 'BASIS_SET_FILE_NAME': 'BASIS_MOLOPT', 'MGRID': { 'NGRIDS': 4, 'CUTOFF': 280, 'REL_CUTOFF': 30, }, 'SCF': { 'MAX_SCF': 3, # limited for testing purpose }, 'XC': { 'XC_FUNCTIONAL': { '_': 'PBE', }, }, }, 'SUBSYS': { 'KIND': [ { '_': 'H', 'BASIS_SET': 'SZV-MOLOPT-SR-GTH', 'POTENTIAL': 'GTH-PBE' }, { '_': 'C', 'BASIS_SET': 'SZV-MOLOPT-SR-GTH', 'POTENTIAL': 'GTH-PBE' }, { '_': 'O', 'BASIS_SET': 'SZV-MOLOPT-SR-GTH', 'POTENTIAL': 'GTH-PBE' }, { '_': 'Zn', 'BASIS_SET': 'SZV-MOLOPT-SR-GTH', 'POTENTIAL': 'GTH-PBE' }, ], }, } }) ddec_params = Dict( dict={ 'net charge': 0.0, 'charge type': 'DDEC6', 'periodicity along A, B, and C vectors': [True, True, True], 'compute BOs': False, 'atomic densities directory complete path': ddec_atdens_path, 'input filename': 'valence_density', }) inputs = { 'metadata': { 'label': 'test-MOF-74' }, 'cp2k_base': { 'cp2k': { 'structure': structure, 'parameters': cp2k_params, 'code': cp2k_code, 'metadata': { 'options': cp2k_options, } } }, 'ddec': { 'parameters': ddec_params, 'code': ddec_code, 'metadata': { 'options': ddec_options, } } } run(Cp2kDdecWorkChain, **inputs)
def test_process(): """Test running a calculation note this does not test that the expected outputs are created of output parsing""" from aiida.plugins import DataFactory, CalculationFactory from aiida.engine import run from aiida.orm import Code, SinglefileData, Int, Float, Str, Bool, List, Dict, ArrayData, XyData, SinglefileData, FolderData, RemoteData import numpy as np import aiida import os aiida.load_profile() #pre-prepared files dmdata = SinglefileData( file=os.path.join(os.getcwd(), "input_files", 'dmdata')) jij = SinglefileData( file=os.path.join(os.getcwd(), "input_files", 'jij')) momfile = SinglefileData( file=os.path.join(os.getcwd(), "input_files", 'momfile')) posfile = SinglefileData( file=os.path.join(os.getcwd(), "input_files", 'posfile')) qfile = SinglefileData( file=os.path.join(os.getcwd(), "input_files", 'qfile')) # inpsd.dat file selection simid = Str('SCsurf_T') ncell = ArrayData() ncell.set_array('matrix', np.array([128, 128, 1])) BC = Str('P P 0 ') cell = ArrayData() cell.set_array('matrix', np.array([[1.00000, 0.00000, 0.00000], [ 0.00000, 1.00000, 0.00000], [0.00000, 0.00000, 1.00000]])) do_prnstruct = Int(2) maptype = Int(2) SDEalgh = Int(1) Initmag = Int(3) ip_mode = Str('Q') qm_svec = ArrayData() qm_svec.set_array('matrix', np.array([1, -1, 0])) qm_nvec = ArrayData() qm_nvec.set_array('matrix', np.array([0, 0, 1])) mode = Str('S') temp = Float(0.000) damping = Float(0.500) Nstep = Int(5000) timestep = Str('1.000d-15') qpoints = Str('F') plotenergy = Int(1) do_avrg = Str('Y') code = Code.get_from_string('uppasd_dev@uppasd_local') r_l = List(list= [f'coord.{simid.value}.out', f'qm_minima.{simid.value}.out', f'qm_sweep.{simid.value}.out', f'qpoints.out', f'totenergy.{simid.value}.out', f'averages.{simid.value}.out', 'fort.2000', 'inp.SCsurf_T.yaml', 'qm_restart.SCsurf_T.out', 'restart.SCsurf_T.out']) # set up calculation inputs = { 'code': code, 'dmdata': dmdata, 'jij': jij, 'momfile': momfile, 'posfile': posfile, 'qfile': qfile, 'simid': simid, 'ncell': ncell, 'BC': BC, 'cell': cell, 'do_prnstruct': do_prnstruct, 'maptype': maptype, 'SDEalgh': SDEalgh, 'Initmag': Initmag, 'ip_mode': ip_mode, 'qm_svec': qm_svec, 'qm_nvec': qm_nvec, 'mode': mode, 'temp': temp, 'damping': damping, 'Nstep': Nstep, 'timestep': timestep, 'qpoints': qpoints, 'plotenergy': plotenergy, 'do_avrg': do_avrg, 'retrieve_list_name': r_l, 'metadata': { 'options': { 'max_wallclock_seconds': 60, 'resources': {'num_machines': 1}, 'input_filename': 'inpsd.dat', 'parser_name': 'UppASD_core_parsers', }, }, } result = run(CalculationFactory('UppASD_core_calculations'), **inputs) computed_diff = result['UppASD_core_calculations'].get_content() assert 'content1' in computed_diff assert 'content2' in computed_diff
def main(codelabel): """Test structure roundtrip precision ase->aiida->cp2k->aiida->ase""" try: code = Code.get_from_string(codelabel) except NotExistent: print("The code '{}' does not exist".format(codelabel)) sys.exit(1) print( "Testing structure roundtrip precision ase->aiida->cp2k->aiida->ase..." ) # structure epsilon = 1e-10 # expected precision in Angstrom dist = 0.74 + epsilon positions = [(0, 0, 0), (0, 0, dist)] cell = np.diag([4, -4, 4 + epsilon]) atoms = ase.Atoms('H2', positions=positions, cell=cell) structure = StructureData(ase=atoms) # parameters parameters = Dict( dict={ 'GLOBAL': { 'RUN_TYPE': 'MD', }, 'MOTION': { 'MD': { 'TIMESTEP': 0.0, # do not move atoms 'STEPS': 1, }, }, 'FORCE_EVAL': { 'METHOD': 'Quickstep', 'DFT': { 'BASIS_SET_FILE_NAME': 'BASIS_MOLOPT', 'SCF': { 'MAX_SCF': 1, }, 'XC': { 'XC_FUNCTIONAL': { '_': 'LDA', }, }, }, 'SUBSYS': { 'KIND': { '_': 'DEFAULT', 'BASIS_SET': 'DZVP-MOLOPT-SR-GTH', 'POTENTIAL': 'GTH-LDA', }, }, }, }) # resources options = { "resources": { "num_machines": 1, "num_mpiprocs_per_machine": 1, }, "max_wallclock_seconds": 1 * 60 * 60, } inputs = { 'structure': structure, 'parameters': parameters, 'code': code, 'metadata': { 'options': options, } } print("submitted calculation...") calc = run(Cp2kCalculation, **inputs) # check structure preservation atoms2 = calc['output_structure'].get_ase() # zeros should be preserved exactly if np.all(atoms2.positions[0] == 0.0): print("OK, zeros in structure were preserved exactly") else: print("ERROR!") print("Zeros in structure changed: ", atoms2.positions[0]) sys.exit(3) # other values should be preserved with epsilon precision dist2 = atoms2.get_distance(0, 1) if abs(dist2 - dist) < epsilon: print("OK, structure preserved with %.1e Angstrom precision" % epsilon) else: print("ERROR!") print("Structure changed by %e Angstrom" % abs(dist - dist2)) sys.exit(3) # check cell preservation cell_diff = np.amax(np.abs(atoms2.cell - cell)) if cell_diff < epsilon: print("OK, cell preserved with %.1e Angstrom precision" % epsilon) else: print("ERROR!") print("Cell changed by %e Angstrom" % cell_diff) sys.exit(3) sys.exit(0)
argkey, argval = sys.argv.pop(0).split('=', 1) else: argkey = sys.argv.pop(0) argval = True if argkey not in options.keys(): options[argkey] = [] options[argkey].append(argval) else: files.append(arg) expected_code_type = "codtools.cifcoddeposit" try: if codename is None: raise ValueError code = Code.get(codename) if code.get_input_plugin_name() != expected_code_type: raise ValueError except (NotExistent, ValueError): valid_code_labels = [c.label for c in Code.query( dbattributes__key="input_plugin", dbattributes__tval=expected_code_type)] if valid_code_labels: print >> sys.stderr, "Pass as further parameter a valid code label." print >> sys.stderr, "Valid labels with a {} executable are:".format(expected_code_type) for l in valid_code_labels: print >> sys.stderr, "*", l else: print >> sys.stderr, "Code not valid, and no valid codes for {}. Configure at least one first using".format( expected_code_type) print >> sys.stderr, " verdi code setup"
from aiida.plugins import DataFactory, WorkflowFactory Qecp = WorkflowFactory('qecpworkchain.cp') StructureData = DataFactory('structure') aiida_structure = aiida.orm.load_node( 42) #some node where you have a structure supercell = aiida_structure.get_pymatgen_structure( ) # eventually replicate the structure supercell.make_supercell([2, 2, 2]) aiida_structure = aiida.orm.StructureData(pymatgen_structure=supercell) build = Qecp.get_builder() #define computing resources pw = Code.get_from_string('qe-6.5@ulysses') cp = Code.get_from_string('cp-6.5@ulysses') resources = { 'resources': { 'num_machines': 1, 'num_mpiprocs_per_machine': 20, }, 'wallclock': 3600 * 3, 'queue': 'regular1', } resourcespw = { 'resources': { 'num_machines': 1, 'num_mpiprocs_per_machine': 20, }, 'wallclock': 600,
""" from __future__ import absolute_import from __future__ import print_function import os from aiida.orm import Code from aiida.common.extendeddicts import AttributeDict from aiida.plugins import DataFactory, CalculationFactory from aiida.engine import run from aiida import load_profile load_profile() from aiida_premod.tests import TEST_DIR # pylint: disable=wrong-import-position # get code code_string = 'premod@localhost' code = Code.get_from_string(code_string) # Set input parameters parameters = AttributeDict() parameters.MODE_SIM = 'PPT' parameters.MODE_ENTITY = 'SD' parameters.MODE_SD = 'EULERIAN' parameters.FILE_OUT_PPT = 'PreModRun.out' parameters.OUTPUT_TIMES = [1800.00, 3600.00, 14400.00, 61200.00, 277200.00] parameters.MODE_IO = 'TXT' parameters.FILE_SOLVER = 'solver.txt' parameters.FILE_ALLOY = 'alloy.txt' parameters.FILE_PROCESS = 'temperature.txt' parameters.FILE_PHASES = 'libphases.txt' parameters.FILE_PPTLIB = 'models.txt' parameters.FILE_PPTSIM = 'libmodel.txt'
inputs['settings'] = ParameterData(dict={'cmdline': ['-nk', str(num_pools)]}) if __name__ == "__main__": import argparse parser = argparse.ArgumentParser(description='NSCF calculation.') parser.add_argument('--code', type=str, dest='codename', required=True, help='The pw codename to use') parser.add_argument('--pseudo', type=str, dest='pseudo', required=True, help='The pseudo family to use') parser.add_argument('--parent', type=int, dest='parent', required=True, help='The parent to use') args = parser.parse_args() code = Code.get_from_string(args.codename) structure = load_node(args.parent).inp.structure inputs['structure'] = structure inputs['pseudo'] = get_pseudos_from_structure(structure, args.pseudo) inputs['code'] = code inputs['parent_folder'] = load_node(args.parent).out.remote_folder process = PwCalculation.process() running = submit(process, **inputs) print "Created calculation; with pid={}".format(running.pid)
def create_builder_from_file(input_folder, input_file_name, code, metadata, pseudo_folder_path=None, use_first=False): """Create a populated process builder for a `PwCalculation` from a standard QE input file and pseudo (upf) files. :param input_folder: the folder containing the input file :type input_folder: aiida.common.folders.Folder or str :param input_file_name: the name of the input file :type input_file_name: str :param code: the code associated with the calculation :type code: aiida.orm.Code or str :param metadata: metadata values for the calculation (e.g. resources) :type metadata: dict :param pseudo_folder_path: the folder containing the upf files (if None, then input_folder is used) :type pseudo_folder_path: aiida.common.folders.Folder or str or None :param use_first: passed to UpfData.get_or_create :type use_first: bool :raises NotImplementedError: if the structure is not ibrav=0 :return: a builder instance for PwCalculation """ PwCalculation = CalculationFactory('quantumespresso.pw') builder = PwCalculation.get_builder() builder.metadata = metadata if isinstance(code, str): code = Code.get_from_string(code) builder.code = code # read input_file if isinstance(input_folder, str): input_folder = Folder(input_folder) with input_folder.open(input_file_name) as input_file: parsed_file = PwInputFile(input_file) builder.structure = parsed_file.get_structuredata() builder.kpoints = parsed_file.get_kpointsdata() if parsed_file.namelists['SYSTEM']['ibrav'] != 0: raise NotImplementedError( 'Found ibrav != 0: `aiida-quantumespresso` currently only supports ibrav = 0.' ) # Then, strip the namelist items that the plugin doesn't allow or sets later. # NOTE: If any of the position or cell units are in alat or crystal # units, that will be taken care of by the input parsing tools, and # we are safe to fake that they were never there in the first place. parameters_dict = copy.deepcopy(parsed_file.namelists) for namelist, blocked_key in PwCalculation._blocked_keywords: # pylint: disable=protected-access for key in list(parameters_dict[namelist].keys()): # take into account that celldm and celldm(*) must be blocked if re.sub('[(0-9)]', '', key) == blocked_key: parameters_dict[namelist].pop(key, None) builder.parameters = Dict(dict=parameters_dict) # Get or create a UpfData node for the pseudopotentials used for the calculation. pseudos_map = {} if pseudo_folder_path is None: pseudo_folder_path = input_folder if isinstance(pseudo_folder_path, str): pseudo_folder_path = Folder(pseudo_folder_path) names = parsed_file.atomic_species['names'] pseudo_file_names = parsed_file.atomic_species['pseudo_file_names'] pseudo_file_map = {} for name, fname in zip(names, pseudo_file_names): if fname not in pseudo_file_map: local_path = pseudo_folder_path.get_abs_path(fname) upf_node, _ = UpfData.get_or_create(local_path, use_first=use_first, store_upf=False) pseudo_file_map[fname] = upf_node pseudos_map[name] = pseudo_file_map[fname] builder.pseudos = pseudos_map settings_dict = {} if parsed_file.k_points['type'] == 'gamma': settings_dict['gamma_only'] = True # If there are any fixed coordinates (i.e. force modification) present in the input file, specify in settings fixed_coords = parsed_file.atomic_positions['fixed_coords'] # Function ``any()`` only works for 1-dimensional lists so we have to call it twice manually. if any((any(fc_xyz) for fc_xyz in fixed_coords)): settings_dict['FIXED_COORDS'] = fixed_coords if settings_dict: builder.settings = settings_dict return builder
def _fixture_code(entry_point_name): from aiida.orm import Code return Code(input_plugin_name=entry_point_name, remote_computer_exec=[fixture_localhost, '/bin/true'])
def get_builder(self, structure, calc_engines, protocol, relaxation_type, threshold_forces=None, threshold_stress=None, previous_workchain=None, **kwargs): """Return a process builder for the corresponding workchain class with inputs set according to the protocol. :param structure: the structure to be relaxed :param calc_engines: ... :param protocol: the protocol to use when determining the workchain inputs :param relaxation_type: the type of relaxation to perform, instance of `RelaxType` :param threshold_forces: target threshold for the forces in eV/Å. :param threshold_stress: target threshold for the stress in eV/Å^3. :param kwargs: any inputs that are specific to the plugin. :return: a `aiida.engine.processes.ProcessBuilder` instance ready to be submitted. """ # pylint: disable=too-many-locals super().get_builder(structure, calc_engines, protocol, relaxation_type, threshold_forces, threshold_stress, previous_workchain, **kwargs) # Get the protocol that we want to use if protocol is None: protocol = self._default_protocol protocol = self.get_protocol(protocol) # Set the builder builder = self.process_class.get_builder() # Set code builder.code = Code.get_from_string(calc_engines['relax']['code']) # Set structure builder.structure = structure # Set options builder.options = DataFactory('dict')( dict=calc_engines['relax']['options']) # Set settings # Make sure we add forces and stress for the VASP parser settings = AttributeDict() settings.update( {'parser_settings': { 'add_forces': True, 'add_stress': True }}) builder.settings = DataFactory('dict')(dict=settings) # Set workchain related inputs, in this case, give more explicit output to report builder.verbose = DataFactory('bool')(True) # Set parameters builder.parameters = DataFactory('dict')(dict=protocol['parameters']) # Set potentials and their mapping builder.potential_family = DataFactory('str')( protocol['potential_family']) builder.potential_mapping = DataFactory('dict')( dict=self._potential_mapping[protocol['potential_mapping']]) # Set the kpoint grid from the density in the protocol kpoints = DataFactory('array.kpoints')() kpoints.set_kpoints_mesh([1, 1, 1]) kpoints.set_cell_from_structure(structure) rec_cell = kpoints.reciprocal_cell kpoints.set_kpoints_mesh( fetch_k_grid(rec_cell, protocol['kpoint_distance'])) builder.kpoints = kpoints # Here we set the protocols fast, moderate and precise. These currently have no formal meaning. # After a while these will be set in the VASP workchain entrypoints using the convergence workchain etc. # However, for now we rely on defaults plane wave cutoffs and a set k-point density for the chosen protocol. relax = AttributeDict() relax.perform = DataFactory('bool')(True) relax.algo = DataFactory('str')(protocol['relax']['algo']) if relaxation_type == RelaxType.ATOMS: relax.positions = DataFactory('bool')(True) relax.shape = DataFactory('bool')(False) relax.volume = DataFactory('bool')(False) elif relaxation_type == RelaxType.CELL: relax.positions = DataFactory('bool')(False) relax.shape = DataFactory('bool')(True) relax.volume = DataFactory('bool')(True) elif relaxation_type == RelaxType.ATOMS_CELL: relax.positions = DataFactory('bool')(True) relax.shape = DataFactory('bool')(True) relax.volume = DataFactory('bool')(True) else: raise ValueError('relaxation type `{}` is not supported'.format( relaxation_type.value)) if threshold_forces is not None: threshold = threshold_forces else: threshold = protocol['relax']['threshold_forces'] relax.force_cutoff = DataFactory('float')(threshold) if threshold_stress is not None: raise ValueError( 'Using a stress threshold is not directly available in VASP during relaxation.' ) builder.relax = relax return builder
def main(): expected_results_calculations = {} expected_results_workchains = {} code = Code.get_from_string(codename) # Submitting the Calculations the new way directly through the launchers print( 'Submitting {} calculations to the daemon'.format(number_calculations)) for counter in range(1, number_calculations + 1): inputval = counter calc, expected_result = launch_calculation(code=code, counter=counter, inputval=inputval) expected_results_calculations[calc.pk] = expected_result # Submitting the Workchains print('Submitting {} workchains to the daemon'.format(number_workchains)) for index in range(number_workchains): inp = Int(index) result, node = run_get_node(NestedWorkChain, inp=inp) expected_results_workchains[node.pk] = index print("Submitting a workchain with 'submit'.") builder = NestedWorkChain.get_builder() input_val = 4 builder.inp = Int(input_val) proc = submit(builder) expected_results_workchains[proc.pk] = input_val print('Submitting a workchain with a nested input namespace.') value = Int(-12) pk = submit(NestedInputNamespace, foo={'bar': {'baz': value}}).pk print('Submitting a workchain with a dynamic non-db input.') value = [4, 2, 3] pk = submit(DynamicNonDbInput, namespace={'input': value}).pk expected_results_workchains[pk] = value print('Submitting a workchain with a dynamic db input.') value = 9 pk = submit(DynamicDbInput, namespace={'input': Int(value)}).pk expected_results_workchains[pk] = value print('Submitting a workchain with a mixed (db / non-db) dynamic input.') value_non_db = 3 value_db = Int(2) pk = submit(DynamicMixedInput, namespace={ 'inputs': { 'input_non_db': value_non_db, 'input_db': value_db } }).pk expected_results_workchains[pk] = value_non_db + value_db print('Submitting the serializing workchain') pk = submit(SerializeWorkChain, test=Int).pk expected_results_workchains[pk] = ObjectLoader().identify_object(Int) print('Submitting the ListEcho workchain.') list_value = List() list_value.extend([1, 2, 3]) pk = submit(ListEcho, list=list_value).pk expected_results_workchains[pk] = list_value print('Submitting a WorkChain which contains a workfunction.') value = Str('workfunction test string') pk = submit(WorkFunctionRunnerWorkChain, input=value).pk expected_results_workchains[pk] = value print('Submitting a WorkChain which contains a calcfunction.') value = Int(1) pk = submit(CalcFunctionRunnerWorkChain, input=value).pk expected_results_workchains[pk] = Int(2) calculation_pks = sorted(expected_results_calculations.keys()) workchains_pks = sorted(expected_results_workchains.keys()) pks = calculation_pks + workchains_pks print('Wating for end of execution...') start_time = time.time() exited_with_timeout = True while time.time() - start_time < timeout_secs: time.sleep(15) # Wait a few seconds # Print some debug info, both for debugging reasons and to avoid # that the test machine is shut down because there is no output print('#' * 78) print('####### TIME ELAPSED: {} s'.format(time.time() - start_time)) print('#' * 78) print("Output of 'verdi process list -a':") try: print( subprocess.check_output( ['verdi', 'process', 'list', '-a'], stderr=subprocess.STDOUT, )) except subprocess.CalledProcessError as e: print('Note: the command failed, message: {}'.format(e)) print("Output of 'verdi daemon status':") try: print( subprocess.check_output( ['verdi', 'daemon', 'status'], stderr=subprocess.STDOUT, )) except subprocess.CalledProcessError as e: print('Note: the command failed, message: {}'.format(e)) if jobs_have_finished(pks): print('Calculation terminated its execution') exited_with_timeout = False break if exited_with_timeout: print_daemon_log() print('') print('Timeout!! Calculation did not complete after {} seconds'.format( timeout_secs)) sys.exit(2) else: # Launch the same calculations but with caching enabled -- these should be FINISHED immediately cached_calcs = [] with enable_caching(identifier='aiida.calculations:templatereplacer'): for counter in range(1, number_calculations + 1): inputval = counter calc, expected_result = run_calculation(code=code, counter=counter, inputval=inputval) cached_calcs.append(calc) expected_results_calculations[calc.pk] = expected_result if (validate_calculations(expected_results_calculations) and validate_workchains(expected_results_workchains) and validate_cached(cached_calcs)): print_daemon_log() print('') print('OK, all calculations have the expected parsed result') sys.exit(0) else: print_daemon_log() print('') print( 'ERROR! Some return values are different from the expected value' ) sys.exit(3)
load_profile() structure = open(sys.argv[1]).read() assert detect_format(structure) == 'cif' ase_obj, error = cif_to_ase(structure) assert not error, error assert 'disordered' not in ase_obj.info try: symprec = float(sys.argv[2]) except: symprec = 3E-02 # NB needs tuning print('symprec = %s' % symprec) label = get_formula(ase_obj) + "/" + spglib.get_spacegroup(ase_obj, symprec=symprec) ase_obj, error = refine(ase_obj, accuracy=symprec, conventional_cell=True) assert not error, error calc_setup = get_template() calc_setup['parameters']['crystal']['title'] = label inputs = MPDSCrystalWorkchain.get_builder() inputs.crystal_code = Code.get_from_string('{}@{}'.format(calc_setup['codes'][0], calc_setup['cluster'])) inputs.crystal_parameters = DataFactory('dict')(dict=calc_setup['parameters']['crystal']) inputs.basis_family, _ = DataFactory('crystal_dft.basis_family').get_or_create(calc_setup['basis_family']) inputs.options = DataFactory('dict')(dict=calc_setup['options']) inputs.metadata = dict(label=label) inputs.mpds_query = DataFactory('dict')() # Add direct structures submitting support: FIXME inputs.struct_in = DataFactory('structure')(ase=ase_obj) wc = submit(MPDSCrystalWorkchain, **inputs) print("Submitted WorkChain %s" % wc.pk)
def test_cif_structure_roundtrip(self): from aiida.tools.dbexporters.tcod import export_cif, export_values from aiida.orm import Code from aiida.orm import JobCalculation from aiida.orm.data.cif import CifData from aiida.orm.data.parameter import ParameterData from aiida.orm.data.upf import UpfData from aiida.orm.data.folder import FolderData from aiida.common.folders import SandboxFolder from aiida.common.datastructures import calc_states import tempfile with tempfile.NamedTemporaryFile() as f: f.write(''' data_test _cell_length_a 10 _cell_length_b 10 _cell_length_c 10 _cell_angle_alpha 90 _cell_angle_beta 90 _cell_angle_gamma 90 loop_ _atom_site_label _atom_site_fract_x _atom_site_fract_y _atom_site_fract_z C 0 0 0 O 0.5 0.5 0.5 ''') f.flush() a = CifData(file=f.name) c = a._get_aiida_structure() c.store() pd = ParameterData() code = Code(local_executable='test.sh') with tempfile.NamedTemporaryFile() as f: f.write("#/bin/bash\n\necho test run\n") f.flush() code.add_path(f.name, 'test.sh') code.store() calc = JobCalculation(computer=self.computer) calc.set_resources({'num_machines': 1, 'num_mpiprocs_per_machine': 1}) calc.add_link_from(code, "code") calc.set_environment_variables({ 'PATH': '/dev/null', 'USER': '******' }) with tempfile.NamedTemporaryFile(prefix="Fe") as f: f.write("<UPF version=\"2.0.1\">\nelement=\"Fe\"\n") f.flush() upf = UpfData(file=f.name) upf.store() calc.add_link_from(upf, "upf") with tempfile.NamedTemporaryFile() as f: f.write("data_test") f.flush() cif = CifData(file=f.name) cif.store() calc.add_link_from(cif, "cif") calc.store() calc._set_state(calc_states.SUBMITTING) with SandboxFolder() as f: calc._store_raw_input_folder(f.abspath) fd = FolderData() with open( fd._get_folder_pathsubfolder.get_abs_path( calc._SCHED_OUTPUT_FILE), 'w') as f: f.write("standard output") f.flush() with open( fd._get_folder_pathsubfolder.get_abs_path( calc._SCHED_ERROR_FILE), 'w') as f: f.write("standard error") f.flush() fd.store() fd.add_link_from(calc, calc._get_linkname_retrieved(), LinkType.CREATE) pd.add_link_from(calc, "calc", LinkType.CREATE) pd.store() with self.assertRaises(ValueError): export_cif(c, parameters=pd) c.add_link_from(calc, "calc", LinkType.CREATE) export_cif(c, parameters=pd) values = export_values(c, parameters=pd) values = values['0'] self.assertEquals(values['_tcod_computation_environment'], ['PATH=/dev/null\nUSER=unknown']) self.assertEquals(values['_tcod_computation_command'], ['cd 1; ./_aiidasubmit.sh'])
import aiida from aiida.orm import Code, Str, Dict import pytest import deliver from deliver import deliver_stage, stage_solution aiida.load_profile("<profile>") deliver.GENERAL_INPUTS = { "code": Code.get_from_string('<code>'), "pseudo_family": Str("<pseudo-family>"), "options": Dict(dict={ 'withmpi': False, 'max_wallclock_seconds': 3600 * 2 }), "parameters": Dict(), } @pytest.mark.parametrize("stage", [1, 2, 3, 4]) def test_solution(stage): deliver_stage(stage, stage_solution(stage).deliverable)
def test_pw_translation(self): from aiida.tools.dbexporters.tcod \ import translate_calculation_specific_values # from aiida.tools.dbexporters.tcod_plugins.pw \ # import PwTcodtranslator as PWT # from aiida.tools.dbexporters.tcod_plugins.cp \ # import CpTcodtranslator as CPT from aiida.orm.code import Code from aiida.orm.data.array import ArrayData from aiida.orm.data.array.kpoints import KpointsData from aiida.orm.data.parameter import ParameterData import numpy from aiida.common.pluginloader import get_plugin PWT = get_plugin('tools.dbexporters.tcod_plugins', 'quantumespresso.pw') CPT = get_plugin('tools.dbexporters.tcod_plugins', 'quantumespresso.cp') code = Code() code._set_attr('remote_exec_path', '/test') kpoints = KpointsData() kpoints.set_kpoints_mesh([2, 3, 4], offset=[0.25, 0.5, 0.75]) def empty_list(): return [] calc = FakeObject({ "inp": { "parameters": ParameterData(dict={}), "kpoints": kpoints, "code": code }, "out": { "output_parameters": ParameterData(dict={}) }, "get_inputs": empty_list }) res = translate_calculation_specific_values(calc, PWT) self.assertEquals( res, { '_dft_BZ_integration_grid_X': 2, '_dft_BZ_integration_grid_Y': 3, '_dft_BZ_integration_grid_Z': 4, '_dft_BZ_integration_grid_shift_X': 0.25, '_dft_BZ_integration_grid_shift_Y': 0.5, '_dft_BZ_integration_grid_shift_Z': 0.75, '_dft_pseudopotential_atom_type': [], '_dft_pseudopotential_type': [], '_dft_pseudopotential_type_other_name': [], '_tcod_software_package': 'Quantum ESPRESSO', '_tcod_software_executable_path': '/test', }) calc = FakeObject({ "inp": { "parameters": ParameterData(dict={ 'SYSTEM': { 'ecutwfc': 40, 'occupations': 'smearing' } }) }, "out": { "output_parameters": ParameterData(dict={ 'number_of_electrons': 10, }) }, "get_inputs": empty_list }) res = translate_calculation_specific_values(calc, PWT) self.assertEquals( res, { '_dft_cell_valence_electrons': 10, '_tcod_software_package': 'Quantum ESPRESSO', '_dft_BZ_integration_smearing_method': 'Gaussian', '_dft_pseudopotential_atom_type': [], '_dft_pseudopotential_type': [], '_dft_pseudopotential_type_other_name': [], '_dft_kinetic_energy_cutoff_EEX': 2176.910676048, '_dft_kinetic_energy_cutoff_charge_density': 2176.910676048, '_dft_kinetic_energy_cutoff_wavefunctions': 544.227669012, }) calc = FakeObject({ "inp": { "parameters": ParameterData(dict={}) }, "out": { "output_parameters": ParameterData(dict={ 'energy_xc': 5, }) }, "get_inputs": empty_list }) with self.assertRaises(ValueError): translate_calculation_specific_values(calc, PWT) calc = FakeObject({ "inp": { "parameters": ParameterData(dict={}) }, "out": { "output_parameters": ParameterData(dict={ 'energy_xc': 5, 'energy_xc_units': 'meV' }) }, "get_inputs": empty_list }) with self.assertRaises(ValueError): translate_calculation_specific_values(calc, PWT) energies = { 'energy': -3701.7004199449257, 'energy_one_electron': -984.0078459766, 'energy_xc': -706.6986753641559, 'energy_ewald': -2822.6335103043157, 'energy_hartree': 811.6396117001462, 'fermi_energy': 10.25208617898623, } dct = energies for key in energies.keys(): dct["{}_units".format(key)] = 'eV' calc = FakeObject({ "inp": { "parameters": ParameterData(dict={'SYSTEM': { 'smearing': 'mp' }}) }, "out": { "output_parameters": ParameterData(dict=dct) }, "get_inputs": empty_list }) res = translate_calculation_specific_values(calc, PWT) self.assertEquals( res, { '_tcod_total_energy': energies['energy'], '_dft_1e_energy': energies['energy_one_electron'], '_dft_correlation_energy': energies['energy_xc'], '_dft_ewald_energy': energies['energy_ewald'], '_dft_hartree_energy': energies['energy_hartree'], '_dft_fermi_energy': energies['fermi_energy'], '_tcod_software_package': 'Quantum ESPRESSO', '_dft_BZ_integration_smearing_method': 'Methfessel-Paxton', '_dft_BZ_integration_MP_order': 1, '_dft_pseudopotential_atom_type': [], '_dft_pseudopotential_type': [], '_dft_pseudopotential_type_other_name': [], }) dct = energies dct['number_of_electrons'] = 10 for key in energies.keys(): dct["{}_units".format(key)] = 'eV' calc = FakeObject({ "inp": { "parameters": ParameterData(dict={'SYSTEM': { 'smearing': 'unknown-method' }}) }, "out": { "output_parameters": ParameterData(dict=dct) }, "get_inputs": empty_list }) res = translate_calculation_specific_values(calc, CPT) self.assertEquals( res, { '_dft_cell_valence_electrons': 10, '_tcod_software_package': 'Quantum ESPRESSO' }) ad = ArrayData() ad.set_array("forces", numpy.array([[[1, 2, 3], [4, 5, 6]]])) calc = FakeObject({ "inp": { "parameters": ParameterData(dict={'SYSTEM': { 'smearing': 'unknown-method' }}) }, "out": { "output_parameters": ParameterData(dict={}), "output_array": ad }, "get_inputs": empty_list }) res = translate_calculation_specific_values(calc, PWT) self.assertEquals( res, { '_tcod_software_package': 'Quantum ESPRESSO', '_dft_BZ_integration_smearing_method': 'other', '_dft_BZ_integration_smearing_method_other': 'unknown-method', '_dft_pseudopotential_atom_type': [], '_dft_pseudopotential_type': [], '_dft_pseudopotential_type_other_name': [], ## Residual forces are no longer produced, as they should ## be in the same CIF loop with coordinates -- to be ## implemented later, since it's not yet clear how. # '_tcod_atom_site_resid_force_Cartn_x': [1,4], # '_tcod_atom_site_resid_force_Cartn_y': [2,5], # '_tcod_atom_site_resid_force_Cartn_z': [3,6], })
def test_remote(self): """Test remote code.""" import tempfile from aiida.orm import Code from aiida.common.exceptions import ValidationError with self.assertRaises(ValueError): # remote_computer_exec has length 2 but is not a list or tuple Code(remote_computer_exec='ab') # invalid code path with self.assertRaises(ValueError): Code(remote_computer_exec=(self.computer, '')) # Relative path is invalid for remote code with self.assertRaises(ValueError): Code(remote_computer_exec=(self.computer, 'subdir/run.exe')) # first argument should be a computer, not a string with self.assertRaises(TypeError): Code(remote_computer_exec=('localhost', '/bin/ls')) code = Code(remote_computer_exec=(self.computer, '/bin/ls')) with tempfile.NamedTemporaryFile(mode='w+') as fhandle: fhandle.write('#/bin/bash\n\necho test run\n') fhandle.flush() code.put_object_from_filelike(fhandle, 'test.sh') with self.assertRaises(ValidationError): # There are files inside code.store() # If there are no files, I can store code.delete_object('test.sh') code.store() self.assertEqual(code.get_remote_computer().pk, self.computer.pk) # pylint: disable=no-member self.assertEqual(code.get_remote_exec_path(), '/bin/ls') self.assertEqual(code.get_execname(), '/bin/ls') self.assertTrue(code.can_run_on(self.computer)) othercomputer = orm.Computer( label='another_localhost', hostname='localhost', transport_type='local', scheduler_type='pbspro', workdir='/tmp/aiida' ).store() self.assertFalse(code.can_run_on(othercomputer))
if not is_dbenv_loaded(): load_dbenv(profile='aiida_test') from aiida.orm import Code, DataFactory from aiida.orm import load_node #from aiida.work.run import run from fleur_workflows.band import fleur_band_wc StructureData = DataFactory('structure') ParameterData = DataFactory('parameter') KpointsData = DataFactory('array.kpoints') FleurinpData = DataFactory('fleur.fleurinp') ############################### # Set your values here codename2 = 'fleur_iff@local_iff' #'fleur_iff003_v0_27@iff003' codename2 = 'fleur_iff003_v0_27@iff003' ############################### code2 = Code.get_from_string(codename2) fleurinp = load_node(1684) fleur_calc = load_node(1693) remote = fleur_calc.out.remote_folder wf_para = ParameterData(dict={'queue': 'th123_node'}) #res = band.run(fleurinp=fleurinp, remote=remote, fleur=code2) res = fleur_band_wc.run(wf_parameters=wf_para, fleurinp=fleurinp, remote=remote, fleur=code2)
def setUpClass(cls, *args, **kwargs): super(TestVerdiCalculation, cls).setUpClass(*args, **kwargs) from aiida.backends.tests.utils.fixtures import import_archive_fixture from aiida.common.exceptions import ModificationNotAllowed from aiida.common.links import LinkType from aiida.orm import Code, Computer, Group, Node, JobCalculation, CalculationFactory from aiida.orm.data.parameter import ParameterData from aiida.orm.querybuilder import QueryBuilder from aiida.work.processes import ProcessState rmq_config = rmq.get_rmq_config() # These two need to share a common event loop otherwise the first will never send # the message while the daemon is running listening to intercept cls.runner = runners.Runner(rmq_config=rmq_config, rmq_submit=True, poll_interval=0.) cls.daemon_runner = runners.DaemonRunner(rmq_config=rmq_config, rmq_submit=True, poll_interval=0.) cls.computer = Computer(name='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida').store() cls.code = Code(remote_computer_exec=(cls.computer, '/bin/true')).store() cls.group = Group(name='test_group').store() cls.node = Node().store() cls.calcs = [] from aiida.orm.backend import construct_backend backend = construct_backend() authinfo = backend.authinfos.create( computer=cls.computer, user=backend.users.get_automatic_user()) authinfo.store() # Create 13 JobCalculations (one for each CalculationState) for calculation_state in calc_states: calc = JobCalculation(computer=cls.computer, resources={ 'num_machines': 1, 'num_mpiprocs_per_machine': 1 }).store() # Trying to set NEW will raise, but in this case we don't need to change the state try: calc._set_state(calculation_state) except ModificationNotAllowed: pass try: exit_status = JobCalculationExitStatus[calculation_state] except KeyError: if calculation_state == 'IMPORTED': calc._set_process_state(ProcessState.FINISHED) else: calc._set_process_state(ProcessState.RUNNING) else: calc._set_exit_status(exit_status) calc._set_process_state(ProcessState.FINISHED) cls.calcs.append(calc) if calculation_state == 'PARSING': cls.KEY_ONE = 'key_one' cls.KEY_TWO = 'key_two' cls.VAL_ONE = 'val_one' cls.VAL_TWO = 'val_two' output_parameters = ParameterData(dict={ cls.KEY_ONE: cls.VAL_ONE, cls.KEY_TWO: cls.VAL_TWO, }).store() output_parameters.add_link_from(calc, 'output_parameters', link_type=LinkType.RETURN) # Create shortcut for easy dereferencing cls.result_job = calc # Add a single calc to a group cls.group.add_nodes([calc]) # Load the fixture containing a single ArithmeticAddCalculation node import_archive_fixture( 'calculation/simpleplugins.arithmetic.add.aiida') # Get the imported ArithmeticAddCalculation node ArithmeticAddCalculation = CalculationFactory( 'simpleplugins.arithmetic.add') calculations = QueryBuilder().append(ArithmeticAddCalculation).all()[0] cls.arithmetic_job = calculations[0]
def test_bands_wc(fresh_aiida_env, potentials, mock_vasp): """Test with mocked vasp code.""" from aiida.orm import Code, Log, RemoteData from aiida.plugins import WorkflowFactory from aiida.engine import run workchain = WorkflowFactory('vasp.bands') mock_vasp.store() create_authinfo(computer=mock_vasp.computer, store=True) structure = PoscarParser(file_path=data_path('test_bands_wc', 'inp', 'POSCAR')).structure parameters = IncarParser(file_path=data_path('test_bands_wc', 'inp', 'INCAR')).incar parameters['system'] = 'test-case:test_bands_wc' # Make sure we replace encut with pwcutoff del parameters['encut'] parameters = {'vasp': parameters} parameters['electronic'] = {'pwcutoff': 200} inputs = AttributeDict() inputs.code = Code.get_from_string('mock-vasp@localhost') inputs.structure = structure inputs.parameters = get_data_node('dict', dict=parameters) inputs.potential_family = get_data_node('str', POTCAR_FAMILY_NAME) inputs.potential_mapping = get_data_node('dict', dict=POTCAR_MAP) inputs.options = get_data_node('dict', dict={ 'withmpi': False, 'queue_name': 'None', 'resources': { 'num_machines': 1, 'num_mpiprocs_per_machine': 1 }, 'max_wallclock_seconds': 3600 }) inputs.max_iterations = get_data_node('int', 1) inputs.clean_workdir = get_data_node('bool', False) inputs.verbose = get_data_node('bool', True) # Also set the restart folder as we assume a bands data will start from # a previous calculation that is sitting in the restart folder inputs.restart_folder = RemoteData(computer=inputs.code.computer, remote_path=data_path('test_bands_wc', 'inp')) results, node = run.get_node(workchain, **inputs) assert node.exit_status == 0 assert 'bands' in results kpoints = results['bands'].get_kpoints() test_array = np.array([[0., 0., 0.], [0.02272727, 0., 0.02272727], [0.04545454, 0., 0.04545454], [0.06818182, 0., 0.06818182], [0.09090909, 0., 0.09090909], [0.11363636, 0., 0.11363636], [0.13636364, 0., 0.13636364], [0.15909091, 0., 0.15909091], [0.18181818, 0., 0.18181818], [0.20454545, 0., 0.20454545], [0.22727273, 0., 0.22727273], [0.25, 0., 0.25], [0.27272727, 0., 0.27272727], [0.29545455, 0., 0.29545455], [0.31818182, 0., 0.31818182], [0.34090909, 0., 0.34090909], [0.36363636, 0., 0.36363636], [0.38636364, 0., 0.38636364], [0.40909091, 0., 0.40909091], [0.43181818, 0., 0.43181818], [0.45454545, 0., 0.45454545], [0.47727273, 0., 0.47727273], [0.5, 0., 0.5], [0.51785714, 0.03571429, 0.51785714], [0.53571429, 0.07142857, 0.53571429], [0.55357143, 0.10714286, 0.55357143], [0.57142857, 0.14285714, 0.57142857], [0.58928571, 0.17857143, 0.58928571], [0.60714286, 0.21428571, 0.60714286], [0.625, 0.25, 0.625], [0.375, 0.375, 0.75], [0.35869565, 0.35869565, 0.7173913], [0.3423913, 0.3423913, 0.68478261], [0.32608696, 0.32608696, 0.65217391], [0.30978261, 0.30978261, 0.61956522], [0.29347826, 0.29347826, 0.58695652], [0.27717391, 0.27717391, 0.55434783], [0.26086957, 0.26086957, 0.52173913], [0.24456522, 0.24456522, 0.48913043], [0.22826087, 0.22826087, 0.45652174], [0.21195652, 0.21195652, 0.42391304], [0.19565217, 0.19565217, 0.39130435], [0.17934783, 0.17934783, 0.35869565], [0.16304348, 0.16304348, 0.32608696], [0.14673913, 0.14673913, 0.29347826], [0.13043478, 0.13043478, 0.26086957], [0.11413044, 0.11413044, 0.22826087], [0.09782609, 0.09782609, 0.19565217], [0.08152174, 0.08152174, 0.16304348], [0.06521739, 0.06521739, 0.13043478], [0.04891304, 0.04891304, 0.09782609], [0.0326087, 0.0326087, 0.06521739], [0.01630435, 0.01630435, 0.0326087], [0., 0., 0.], [0.02631579, 0.02631579, 0.02631579], [0.05263158, 0.05263158, 0.05263158], [0.07894737, 0.07894737, 0.07894737], [0.10526316, 0.10526316, 0.10526316], [0.13157895, 0.13157895, 0.13157895], [0.15789474, 0.15789474, 0.15789474], [0.18421053, 0.18421053, 0.18421053], [0.21052632, 0.21052632, 0.21052632], [0.2368421, 0.2368421, 0.2368421], [0.26315789, 0.26315789, 0.26315789], [0.28947368, 0.28947368, 0.28947368], [0.31578947, 0.31578947, 0.31578947], [0.34210526, 0.34210526, 0.34210526], [0.36842105, 0.36842105, 0.36842105], [0.39473684, 0.39473684, 0.39473684], [0.42105263, 0.42105263, 0.42105263], [0.44736842, 0.44736842, 0.44736842], [0.47368421, 0.47368421, 0.47368421], [0.5, 0.5, 0.5], [0.5, 0.48333333, 0.51666667], [0.5, 0.46666667, 0.53333333], [0.5, 0.45, 0.55], [0.5, 0.43333333, 0.56666667], [0.5, 0.41666667, 0.58333333], [0.5, 0.4, 0.6], [0.5, 0.38333333, 0.61666667], [0.5, 0.36666667, 0.63333333], [0.5, 0.35, 0.65], [0.5, 0.33333333, 0.66666667], [0.5, 0.31666667, 0.68333333], [0.5, 0.3, 0.7], [0.5, 0.28333333, 0.71666667], [0.5, 0.26666667, 0.73333333], [0.5, 0.25, 0.75], [0.5, 0.225, 0.725], [0.5, 0.2, 0.7], [0.5, 0.175, 0.675], [0.5, 0.15, 0.65], [0.5, 0.125, 0.625], [0.5, 0.1, 0.6], [0.5, 0.075, 0.575], [0.5, 0.05, 0.55], [0.5, 0.025, 0.525], [0.5, 0., 0.5]]) np.testing.assert_allclose(kpoints, test_array) bands = results['bands'].get_bands() assert bands.shape == (1, 98, 20) np.testing.assert_allclose(bands[0, 0, 0:3], np.array([-6.0753, 6.0254, 6.0254])) np.testing.assert_allclose(bands[0, 2, 0:3], np.array([-6.0386, 5.7955, 5.8737])) np.testing.assert_allclose(bands[0, 97, 0:3], np.array([-1.867, -1.867, 3.1102]))
lammps_machine = { 'num_machines': 1, 'parallel_env': 'mpi*', 'tot_num_mpiprocs': 16 } parameters_md = { 'timestep': 0.001, 'temperature': 300, 'thermostat_variable': 0.5, 'equilibrium_steps': 100, 'total_steps': 2000, 'dump_rate': 1 } code = Code.get_from_string(codename) calc = code.new_calc(max_wallclock_seconds=3600, resources=lammps_machine) calc.label = "test lammps calculation" calc.description = "A much longer description" calc.use_code(code) calc.use_structure(structure) calc.use_potential(ParameterData(dict=potential)) calc.use_parameters(ParameterData(dict=parameters_md)) test_only = False if test_only: # It will not be submitted import os
def test_converge_wc_pw(fresh_aiida_env, vasp_params, potentials, mock_vasp): """Test convergence workflow using mock code.""" from aiida.orm import Code from aiida.plugins import WorkflowFactory from aiida.engine import run workchain = WorkflowFactory('vasp.converge') mock_vasp.store() create_authinfo(computer=mock_vasp.computer).store() structure = PoscarParser(file_path=data_path('test_converge_wc/pw/200', 'inp', 'POSCAR')).structure parameters = IncarParser( file_path=data_path('test_converge_wc/pw/200', 'inp', 'INCAR')).incar parameters['system'] = 'test-case:test_converge_wc' parameters = { k: v for k, v in parameters.items() if k not in ['isif', 'ibrion', 'encut', 'nsw'] } kpoints = KpointsParser(file_path=data_path('test_converge_wc/pw/200', 'inp', 'KPOINTS')).kpoints restart_clean_workdir = get_data_node('bool', False) restart_clean_workdir.store() inputs = AttributeDict() inputs.code = Code.get_from_string('mock-vasp@localhost') inputs.structure = structure inputs.kpoints = kpoints inputs.parameters = get_data_node('dict', dict={'incar': parameters}) inputs.potential_family = get_data_node('str', POTCAR_FAMILY_NAME) inputs.potential_mapping = get_data_node('dict', dict=POTCAR_MAP) inputs.options = get_data_node('dict', dict={ 'withmpi': False, 'queue_name': 'None', 'resources': { 'num_machines': 1, 'num_mpiprocs_per_machine': 1 }, 'max_wallclock_seconds': 3600 }) inputs.max_iterations = get_data_node('int', 1) inputs.clean_workdir = get_data_node('bool', False) relax = AttributeDict() converge = AttributeDict() relax.perform = get_data_node('bool', False) converge.relax = get_data_node('bool', False) converge.testing = get_data_node('bool', True) converge.compress = get_data_node('bool', False) converge.displace = get_data_node('bool', False) converge.pwcutoff_samples = get_data_node('int', 3) converge.k_samples = get_data_node('int', 3) inputs.relax = relax inputs.converge = converge inputs.verbose = get_data_node('bool', True) results, node = run.get_node(workchain, **inputs) assert node.exit_status == 0 assert 'converge' in results converge = results['converge'] assert 'data' in converge conv_data = converge['data'] try: conv_data = conv_data.get_array('pw_regular') except KeyError: pytest.fail('Did not find pw_regular in converge.data') conv_data_test = np.array([[200.0, -10.77974998, 0.0, 0.0, 0.5984], [250.0, -10.80762044, 0.0, 0.0, 0.5912], [300.0, -10.82261992, 0.0, 0.0, 0.5876]]) np.testing.assert_allclose(conv_data, conv_data_test) assert 'pwcutoff_recommended' in converge try: _encut = converge['pwcutoff_recommended'].value np.testing.assert_equal(_encut, 300) except AttributeError: pytest.fail('pwcutoff_recommended does not have the expected format')
def test_converge_wc(fresh_aiida_env, potentials, mock_vasp): """Test submitting only, not correctness, with mocked vasp code.""" from aiida.orm import Code from aiida.plugins import WorkflowFactory from aiida.engine import run workchain = WorkflowFactory('vasp.converge') mock_vasp.store() create_authinfo(computer=mock_vasp.computer, store=True) structure = PoscarParser( file_path=data_path('test_converge_wc', 'inp', 'POSCAR')).structure parameters = IncarParser( file_path=data_path('test_converge_wc', 'inp', 'INCAR')).incar parameters['system'] = 'test-case:test_converge_wc' parameters = { k: v for k, v in parameters.items() if k not in ['isif', 'ibrion', 'encut', 'nsw'] } restart_clean_workdir = get_data_node('bool', False) restart_clean_workdir.store() inputs = AttributeDict() inputs.code = Code.get_from_string('mock-vasp@localhost') inputs.structure = structure inputs.parameters = get_data_node('dict', dict={'incar': parameters}) inputs.potential_family = get_data_node('str', POTCAR_FAMILY_NAME) inputs.potential_mapping = get_data_node('dict', dict=POTCAR_MAP) inputs.options = get_data_node('dict', dict={ 'withmpi': False, 'queue_name': 'None', 'resources': { 'num_machines': 1, 'num_mpiprocs_per_machine': 1 }, 'max_wallclock_seconds': 3600 }) inputs.max_iterations = get_data_node('int', 1) inputs.clean_workdir = get_data_node('bool', False) relax = AttributeDict() converge = AttributeDict() converge.relax = get_data_node('bool', False) converge.compress = get_data_node('bool', False) converge.displace = get_data_node('bool', False) converge.pwcutoff_samples = get_data_node('int', 3) converge.k_samples = get_data_node('int', 3) relax.perform = get_data_node('bool', True) inputs.relax = relax inputs.converge = converge inputs.verbose = get_data_node('bool', True) results, node = run.get_node(workchain, **inputs) assert node.exit_status == 0 converge = results['converge'] assert 'data' in converge conv_data = converge['data'] try: conv_data.get_array('pw_regular') except KeyError: pytest.fail('Did not find pw_regular in converge.data') try: conv_data.get_array('kpoints_regular') except KeyError: pytest.fail('Did not find kpoints_regular in converge.data') assert 'pwcutoff_recommended' in converge try: _encut = converge['pwcutoff_recommended'].value except AttributeError: pytest.fail('pwcutoff_recommended does not have the expected format') assert 'kpoints_recommended' in converge try: _kpoints = converge['kpoints_recommended'].get_kpoints_mesh() except AttributeError: pytest.fail('kpoints_recommended does not have the expected format')
#!/usr/bin/env python #from aiida.backends.utils import load_dbenv #load_dbenv() codename = 'QE5.4@daint-gpu' from aiida.orm import Code code = Code.get_from_string(codename) from aiida.orm import DataFactory StructureData = DataFactory('structure') alat = 5.4 # angstrom cell = [[alat, 0.10, 0.20,], [0.30, alat, 0.40,], [0.50, 0.60, alat,], ] s = StructureData(cell=cell) s.append_atom(position=(0.,0.,0.),symbols='Si') s.append_atom(position=(alat/2.,alat/2.,0.),symbols='Si') s.append_atom(position=(alat/2.,0.,alat/2.),symbols='Si') s.append_atom(position=(0.,alat/2.,alat/2.),symbols='Si') s.append_atom(position=(alat/4.,alat/4.,alat/4.),symbols='Si') s.append_atom(position=(3.*alat/4.,3.*alat/4.,alat/4.),symbols='Si') s.append_atom(position=(3.*alat/4.,alat/4.,3.*alat/4.),symbols='Si') s.append_atom(position=(alat/4.,3.*alat/4.,3.*alat/4.),symbols='Si') ParameterData = DataFactory('parameter') parameters = ParameterData(dict={ 'CONTROL': { 'calculation': 'relax', 'restart_mode': 'from_scratch', 'wf_collect': True, 'tprnfor': True, 'tstress': True, },