def validate_kpoint_mesh(callback_kwargs, ctx, param, value): """ Command line option validator for a kpoints mesh tuple. The value should be a tuple of three positive integers out of which a KpointsData object will be created with a mesh equal to the tuple. :param callback_kwargs: an optional dictionary with arguments for internal use in the validator :param ctx: internal context of the click.command :param param: the click Parameter, i.e. either the Option or Argument to which the validator is hooked up :param value: a tuple of three positive integers :returns: a KpointsData instance """ from aiida.orm.data.array.kpoints import KpointsData if any([type(i) != int for i in value]) or any([int(i) <= 0 for i in value]): raise click.BadParameter( 'all values of the tuple should be positive greater than zero integers' ) try: kpoints = KpointsData() kpoints.set_kpoints_mesh(value) except ValueError as exception: raise click.BadParameter( "failed to create a KpointsData mesh out of {}\n{}".format( value, exception)) return kpoints
def setup_kpoints(self): """ Define the k-point mesh for the Siesta calculation. """ self.report('Running setup_kpoints') kpoints_mesh = KpointsData() kpmesh=self.ctx.protocol['kpoints_mesh'] kpoints_mesh.set_kpoints_mesh([kpmesh,kpmesh,kpmesh]) self.ctx.kpoints_mesh = kpoints_mesh
def _get_kpoints(self, nx, use_symmetry=True): nx = max(1, nx) kpoints = KpointsData() if use_symmetry: kpoints.set_kpoints_mesh([nx, 1, 1], offset=[0.0, 0.0, 0.0]) else: # list kpoints explicitly points = [[r, 0.0, 0.0] for r in np.linspace(0, 0.5, nx)] kpoints.set_kpoints(points) return kpoints
def execute(args): """ The main execution of the script, which will run some preliminary checks on the command line arguments before passing them to the workchain and running it """ try: code = Code.get_from_string(args.codename) except NotExistent as exception: print "Execution failed: could not retrieve the code '{}'".format(args.codename) print "Exception report: {}".format(exception) return try: parent_calc = load_node(args.parent_calc) except NotExistent as exception: print "Execution failed: failed to load the node for the given parent calculation '{}'".format(args.parent_calc) print "Exception report: {}".format(exception) return if not isinstance(parent_calc, PwCalculation): print "The provided parent calculation {} is not of type PwCalculation, aborting...".format(args.parent_calc) return qpoints = KpointsData() qpoints.set_kpoints_mesh(args.qpoints) parameters = { 'INPUTPH': { 'tr2_ph': 1e-10, } } settings = {} options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': args.max_wallclock_seconds, } run( PhBaseWorkChain, code=code, parent_calc=parent_calc, qpoints=qpoints, parameters=ParameterData(dict=parameters), settings=ParameterData(dict=settings), options=ParameterData(dict=options), max_iterations=Int(args.max_iterations) )
def get_kpointsdata(self): """ Return a KpointsData object based on the data in the input file. This uses all of the data in the input file to do the necessary unit conversion, ect. and then creates an AiiDa KpointsData object. **Note:** If the calculation uses only the gamma k-point (`if self.k_points['type'] == 'gamma'`), it is necessary to also attach a settings node to the calculation with `gamma_only = True`. :return: KpointsData object of the kpoints in the input file :rtype: aiida.orm.data.array.kpoints.KpointsData :raises NotImplementedError: if the kpoints are in a format not yet supported. """ from aiida.orm.data.array.kpoints import KpointsData # Initialize the KpointsData node kpointsdata = KpointsData() # Get the structure using this class's method. structuredata = self.get_structuredata() # Set the structure information of the kpoints node. kpointsdata.set_cell_from_structure(structuredata) # Set the kpoints and weights, doing any necessary units conversion. if self.k_points['type'] == 'crystal': # relative to recip latt vecs kpointsdata.set_kpoints(self.k_points['points'], weights=self.k_points['weights']) elif self.k_points['type'] == 'tpiba': # cartesian; units of 2*pi/alat alat = np.linalg.norm(structuredata.cell[0]) # alat in Angstrom kpointsdata.set_kpoints(np.array(self.k_points['points']) * (2. * np.pi / alat), weights=self.k_points['weights'], cartesian=True) elif self.k_points['type'] == 'automatic': kpointsdata.set_kpoints_mesh(self.k_points['points'], offset=self.k_points['offset']) elif self.k_points['type'] == 'gamma': kpointsdata.set_kpoints_mesh([1, 1, 1]) else: raise NotImplementedError( 'Support for creating KpointsData from input units of {} is' 'not yet implemented'.format(self.k_points['type'])) return kpointsdata
def execute(args): """ The main execution of the script, which will run some preliminary checks on the command line arguments before passing them to the workchain and running it """ try: code = Code.get_from_string(args.codename) except NotExistent as exception: print "Execution failed: could not retrieve the code '{}'".format(args.codename) print "Exception report: {}".format(exception) return try: structure = load_node(args.structure) except NotExistent as exception: print "Execution failed: failed to load the node for the given structure pk '{}'".format(args.structure) print "Exception report: {}".format(exception) return if not isinstance(structure, StructureData): print "The provided pk {} for the structure does not correspond to StructureData, aborting...".format(args.parent_calc) return kpoints = KpointsData() kpoints.set_kpoints_mesh(args.kpoints) parameters = load_property_json('parameters.json') basis = load_property_json('basis.json') settings = load_property_json('settings.json') options = load_property_json('options.json') options['max_wallclock_seconds'] = args.max_wallclock_seconds run( SiestaWorkChain, code=code, structure=structure, pseudo_family=Str(args.pseudo_family), kpoints=kpoints, parameters=ParameterData(dict=parameters), settings=ParameterData(dict=settings), options=ParameterData(dict=options), basis=ParameterData(dict=basis), max_iterations=Int(args.max_iterations), )
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 execute(args): """ The main execution of the script, which will run some preliminary checks on the command line arguments before passing them to the workchain and running it """ try: code = Code.get_from_string(args.codename) except NotExistent as exception: print "Execution failed: could not retrieve the code '{}'".format(args.codename) print "Exception report: {}".format(exception) return try: structure = load_node(args.structure) except: # # Slightly distorted structure # alat = 5.430 # angstrom cell = [[0.5*alat, 0.5*alat, 0.,], [0., 0.5*alat, 0.5*alat,], [0.5*alat, 0., 0.5*alat,], ] # Si # This was originally given in the "ScaledCartesian" format # structure = StructureData(cell=cell) structure.append_atom(position=(0.000*alat,0.000*alat,0.000*alat),symbols=['Si']) structure.append_atom(position=(0.250*alat,0.245*alat,0.250*alat),symbols=['Si']) #print "Execution failed: failed to load the node for the given structure pk '{}'".format(args.structure) #print "Exception report: {}".format(exception) #return if not isinstance(structure, StructureData): print "The provided pk {} for the structure does not correspond to StructureData, aborting...".format(args.parent_calc) return kpoints = KpointsData() kpoints.set_kpoints_mesh(args.kpoints) bandskpoints = KpointsData() bandskpoints.set_cell(structure.cell, structure.pbc) bandskpoints.set_kpoints_path(kpoint_distance = 0.05) parameters = { 'xc-functional': 'LDA', 'xc-authors': 'CA', 'spinpolarized': False, 'meshcutoff': '150.0 Ry', 'max-scfiterations': 50, 'dm-numberpulay': 4, 'dm-mixingweight': 0.3, 'dm-tolerance': 1.e-4, 'Solution-method': 'diagon', 'electronic-temperature': '25 meV', 'md-typeofrun': 'cg', 'md-numcgsteps': 10, 'md-maxcgdispl': '0.1 Ang', 'md-maxforcetol': '0.04 eV/Ang' } # default basis basis = { 'pao-energy-shift': '100 meV', '%block pao-basis-sizes': """ Si DZP """, } settings = {} options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': args.max_wallclock_seconds, } run( SiestaBaseWorkChain, code=code, structure=structure, pseudo_family=Str(args.pseudo_family), kpoints=kpoints, bandskpoints=bandskpoints, parameters=ParameterData(dict=parameters), settings=ParameterData(dict=settings), options=ParameterData(dict=options), basis=ParameterData(dict=basis), max_iterations=Int(args.max_iterations), )
alat=5.4 alat2=alat/2 alat3=alat2/2 from aiida.orm.data.array.kpoints import KpointsData kpoints = KpointsData() kpoints_mesh = 2 kpoints.set_kpoints_mesh([kpoints_mesh,kpoints_mesh,kpoints_mesh]) StructureData = DataFactory("structure") the_cell = [[alat/2,alat/2,0.],[alat/2,0.,alat/2],[0.,alat/2,alat/2]] structure = StructureData(cell=the_cell) structure.cell structure.append_atom(position=(alat/4.,alat/4.,alat/4.),symbols="Si") structure.sites from ase.lattice.spacegroup import crystal ase_structure = crystal('Si', [(0,0,0)], spacegroup=227, cellpar=[alat, alat, alat, 90, 90, 90],primitive_cell=True) structure=StructureData(ase=ase_structure) structure.store() nameCode='pw@local-seb' code=Code.get_from_string(nameCode) calc=code.new_calc() calc.label="PW test" calc.description="First calculus on BaTiO3" calc.set_resources({"num_machines": 1}) calc.set_max_wallclock_seconds(30*60)
def execute(args): """ The main execution of the script, which will run some preliminary checks on the command line arguments before passing them to the workchain and running it """ try: code = Code.get_from_string(args.codename) except NotExistent as exception: print "Execution failed: could not retrieve the code '{}'".format( args.codename) print "Exception report: {}".format(exception) return try: structure = load_node(args.structure) except NotExistent as exception: print "Execution failed: failed to load the node for the given structure pk '{}'".format( args.structure) print "Exception report: {}".format(exception) return if not isinstance(structure, StructureData): print "The provided pk {} for the structure does not correspond to StructureData, aborting...".format( args.parent_calc) return kpoints = KpointsData() kpoints.set_kpoints_mesh(args.kpoints) parameters = { 'xc-functional': 'LDA', 'xc-authors': 'CA', 'mesh-cutoff': '100.000 Ry', 'max-scfiterations': 30, 'dm-numberpulay': 4, 'dm-mixingweight': 0.1, 'dm-tolerance': 1.e-4, 'md-typeofrun': 'cg', 'md-numcgsteps': 8, 'md-maxcgdispl': '0.200 bohr', 'md-maxforcetol': '0.020 eV/Ang', 'geometry-must-converge': True, 'xml-write': True } # default basis basis = {} settings = {} options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': args.max_wallclock_seconds, } run( SiestaBaseWorkChain, code=code, structure=structure, pseudo_family=Str(args.pseudo_family), kpoints=kpoints, parameters=ParameterData(dict=parameters), settings=ParameterData(dict=settings), options=ParameterData(dict=options), basis=ParameterData(dict=basis), max_iterations=Int(args.max_iterations), )
def execute(args): """ The main execution of the script, which will run some preliminary checks on the command line arguments before passing them to the workchain and running it """ try: code = Code.get_from_string(args.codename) except NotExistent as exception: print "Execution failed: could not retrieve the code '{}'".format(args.codename) print "Exception report: {}".format(exception) return try: structure = load_node(args.structure) except NotExistent as exception: print "Execution failed: failed to load the node for the given structure pk '{}'".format(args.structure) print "Exception report: {}".format(exception) return if not isinstance(structure, StructureData): print "The provided pk {} for the structure does not correspond to StructureData, aborting...".format(args.parent_calc) return kpoints = KpointsData() kpoints.set_kpoints_mesh(args.kpoints) parameters = { 'xc:functional': 'LDA', 'xc:authors': 'CA', 'spinpolarized': True, 'meshcutoff': '40.000 Ry', 'dm:numberpulay': 4, 'dm:mixingweight': 0.3, 'dm:tolerance': 1.e-3, 'max-scfiterations': 3, 'scf-must-converge': True, 'Solution-method': 'diagon', 'electronic-temperature': '25 meV', 'md-typeofrun': 'CG', 'md-numcgsteps': 0, 'md-maxcgdispl': '0.1 Ang', 'md-maxforcetol': '0.04 eV/Ang', 'writeforces': True, 'writecoorstep': True } basis = { 'pao-energy-shift': '300 meV', '%block pao-basis-sizes': """ Si DZP """, } settings = {} options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': args.max_wallclock_seconds, } run( SiestaBaseWorkChain, code=code, structure=structure, pseudo_family=Str(args.pseudo_family), kpoints=kpoints, parameters=ParameterData(dict=parameters), settings=ParameterData(dict=settings), options=ParameterData(dict=options), basis=ParameterData(dict=basis), max_iterations=Int(args.max_iterations), )
def execute(args): """ The main execution of the script, which will run some preliminary checks on the command line arguments before passing them to the workchain and running it """ try: code = Code.get_from_string(args.codename) except NotExistent as exception: print "Execution failed: could not retrieve the code '{}'".format(args.codename) print "Exception report: {}".format(exception) return alat = 10.0 # angstrom cell = [[alat, 0., 0.,], [0., alat, 0.,], [0., 0., alat,], ] # Water molecule # One of the H atoms is sligthy moved s = StructureData(cell=cell) s.append_atom(position=(0.000,0.000,0.00),symbols=['O']) s.append_atom(position=(0.757,0.586,0.00),symbols=['H']) s.append_atom(position=(-0.780,0.600,0.00),symbols=['H']) structure = s kpoints = KpointsData() kpoints.set_kpoints_mesh(args.kpoints) parameters = { 'meshcutoff': '80.000 Ry', 'dm:numberpulay': 4, 'dm:mixingweight': 0.2, 'dm:tolerance': 1.e-3, 'max-scfiterations': 30, 'scf-must-converge': True, 'geometry-must-converge': True, 'electronic-temperature': '25 meV', 'md-typeofrun': 'CG', 'md-numcgsteps': 6, 'md-maxcgdispl': '0.1 Ang', 'md-maxforcetol': '0.03 eV/Ang', 'xml:write': True } basis = { 'pao-energy-shift': '300 meV', 'pao-basis-size': 'DZP' } settings = {} options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': args.max_wallclock_seconds, } run( SiestaBaseWorkChain, code=code, structure=structure, pseudo_family=Str(args.pseudo_family), kpoints=kpoints, parameters=ParameterData(dict=parameters), settings=ParameterData(dict=settings), options=ParameterData(dict=options), basis=ParameterData(dict=basis), max_iterations=Int(args.max_iterations), )
from aiida.orm.data.array.kpoints import KpointsData from aiida.orm.data.parameter import ParameterData from aiida.workflows.user.base import VASPBaseWorkChain 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),
}, 'max_wallclock_seconds': 60 * 60 * 10, }) wannier90_parameters = ParameterData( dict={ 'bands_plot': False, 'num_iter': 12, 'guiding_centres': True, 'num_wann': 4, #'exclude_bands': exclude_bands, # 'wannier_plot':True, # 'wannier_plot_list':[1] }) structure = load_node(152) scf_kpoints = KpointsData() scf_kpoints.set_kpoints_mesh([4, 4, 4]) nscf_kpoints = KpointsData() nscf_kpoints.set_kpoints_mesh([4, 4, 4]) projections = List() projections.extend(['As:s', 'As:p']) wc = submit( SimpleWannier90WorkChain, pw_code=Code.get_from_string('pw_6.1@fidis'), pw2wannier90_code=Code.get_from_string('pw2wannier90_6.1@fidis'), wannier90_code=Code.get_from_string('wannier90_2.1@fidis'), #orbital_projections=projections, structure=structure, pseudo_family=Str('SSSP_efficiency_v0.95'), #wannier90_parameters=wannier90_parameters, scf={ 'parameters': scf_parameters,
def execute(args): """ The main execution of the script, which will run some preliminary checks on the command line arguments before passing them to the workchain and running it """ try: siesta_code = Code.get_from_string(args.siesta_codename) except NotExistent as exception: print "Execution failed: could not retrieve the code '{}'".format( args.siesta_codename) print "Exception report: {}".format(exception) return try: gollum_code = Code.get_from_string(args.gollum_codename) except NotExistent as exception: print "Execution failed: could not retrieve the code '{}'".format( args.gollum_codename) print "Exception report: {}".format(exception) return protocol = Str(args.protocol) ###### Siesta structures ############################## alat = 1.00 # Angstrom. Not passed to the fdf file # Leads cellle = [[ 20., 0., 0., ], [ 0., 20., 0., ], [ 0., 0., 5., ]] sle = StructureData(cell=cellle) for i in range(0, 2): sle.append_atom(position=(0., 0., i * 2.5), symbols=['Au']) if args.structure_em > 0: structure_le = load_node(args.structure_le) else: structure_le = sle # Extended molecule cellem = [[ 20., 0., 0., ], [ 0., 20., 0., ], [ 0., 0., 45., ]] sem = StructureData(cell=cellem) for i in range(0, 18): sem.append_atom(position=(0., 0., i * 2.5), symbols=['Au']) if args.structure_em > 0: structure_em = load_node(args.structure_em) else: structure_em = sem ###### Siesta k-ppoints ############################### kpoints_le = KpointsData() kpoints_le.set_kpoints_mesh([1, 1, 90]) kpoints_em = KpointsData() kpoints_em.set_kpoints_mesh([1, 1, 10]) ###### Gollum parameters ############################## # The "atom" block is definied independently pms = { 'NBlock leadp': """ 2 2 -1 2 2 1 """, 'atom': """ 1 2 2 0 0 10 2 2 2 """ } parameters = ParameterData(dict=pms) ###### run(GollumSiestaWorkChain, siesta_code=siesta_code, gollum_code=gollum_code, structure_le=structure_le, structure_em=structure_em, protocol=protocol, kpoints_le=kpoints_le, kpoints_em=kpoints_em, parameters=parameters)
def execute(args): """ The main execution of the script, which will run some preliminary checks on the command line arguments before passing them to the workchain and running it """ try: code = Code.get_from_string(args.codename) except NotExistent as exception: print "Execution failed: could not retrieve the code '{}'".format( args.codename) print "Exception report: {}".format(exception) return try: structure = load_node(args.structure) except NotExistent as exception: print "Execution failed: failed to load the node for the given structure pk '{}'".format( args.structure) print "Exception report: {}".format(exception) return if not isinstance(structure, StructureData): print "The provided pk {} for the structure does not correspond to StructureData, aborting...".format( args.parent_calc) return kpoints = KpointsData() kpoints.set_kpoints_mesh(args.kpoints) parameters = { 'CONTROL': { 'restart_mode': 'from_scratch', 'calculation': 'scf', 'tstress': True, }, 'SYSTEM': { 'ecutwfc': 40., 'ecutrho': 320., }, 'ELECTRONS': { 'conv_thr': 1.e-10, } } settings = {} options = { 'resources': { 'num_machines': 1 }, 'max_wallclock_seconds': args.max_wallclock_seconds, } run( PwBaseWorkChain, code=code, structure=structure, pseudo_family=Str(args.pseudo_family), kpoints=kpoints, parameters=ParameterData(dict=parameters), settings=ParameterData(dict=settings), options=ParameterData(dict=options), max_iterations=Int(args.max_iterations), )