def test_test_and_get_code(self):
"""
Checks that the test_and_get_code functions of the example_helpers
file behaves as expected.
"""
from aiida.common.example_helpers import test_and_get_code
# When asking an existing code, the returned code
# should be the right one
code = test_and_get_code('test_code', 'test_input_plugin')
self.assertEquals(code.label, self.CODE_LABEL,
"The code name is not the expected one.")
self.assertEquals(
code.get_input_plugin_name(), self.INPUT_PLUGIN_NAME,
"The input plugin name of the code is not the "
"expected one.")
# Check the correct behaviour of the function when asking a code that
# doesn't exist and when the input doesn't also exist
with self.assertRaises(ValueError):
test_and_get_code('no_code',
'no_input_plugin',
use_exceptions=True)
with self.assertRaises(ValueError):
test_and_get_code('no_code',
self.INPUT_PLUGIN_NAME,
use_exceptions=True)
def main(codelabel, block_pockets, submit):
code = test_and_get_code(codelabel, expected_code_type='raspa')
# calc object
calc = code.new_calc()
# parameters
parameters = ParameterData(
dict={
"GeneralSettings": {
"SimulationType": "MonteCarlo",
"NumberOfCycles": 2000,
"NumberOfInitializationCycles": 2000,
"PrintEvery": 1000,
"Forcefield": "GenericMOFs",
"EwaldPrecision": 1e-6,
"CutOff": 12.0,
"Framework": 0,
"UnitCells": "1 1 1",
"HeliumVoidFraction": 0.149,
"ExternalTemperature": 300.0,
"ExternalPressure": 5e5,
},
"Component": [{
"MoleculeName": "methane",
"MoleculeDefinition": "TraPPE",
"TranslationProbability": 0.5,
"ReinsertionProbability": 0.5,
"SwapProbability": 1.0,
"CreateNumberOfMolecules": 0,
}],
})
calc.use_parameters(parameters)
# structure
pwd = os.path.dirname(os.path.realpath(__file__))
framework = CifData(file=pwd + '/test_raspa_attach_file/TCC1RS.cif')
calc.use_structure(framework)
# block pockets
bp = load_node(block_pockets)
calc.use_block_component_0(bp)
# resources
calc.set_max_wallclock_seconds(30 * 60) # 30 min
calc.set_resources({"num_machines": 1, "num_mpiprocs_per_machine": 1})
calc.set_withmpi(False)
#calc.set_queue_name("serial")
if submit:
calc.store_all()
calc.submit()
print(("submitted calculation; calc=Calculation(uuid='{}') # ID={}"\
.format(calc.uuid,calc.dbnode.pk)))
else:
subfolder = calc.submit_test()[0]
path = os.path.relpath(subfolder.abspath)
print("submission test successful")
print(("Find remote folder in {}".format(path)))
print("In order to actually submit, add '--submit'")
def main(codelabel, submit):
code = test_and_get_code(codelabel, expected_code_type='raspa')
# calc object
calc = code.new_calc()
# parameters
parameters = ParameterData(
dict={
"GeneralSettings": {
"SimulationType": "MonteCarlo",
"NumberOfCycles": 2000,
"NumberOfInitializationCycles": 2000,
"PrintEvery": 1000,
"Forcefield": "GenericMOFs",
"EwaldPrecision": 1e-6,
"CutOff": 12.0,
"Box": 0,
"BoxLengths": "25 25 25",
"ExternalTemperature": 300.0,
"ExternalPressure": 5e5,
},
"Component": [{
"MoleculeName": "propane",
"MoleculeDefinition": "TraPPE",
"TranslationProbability": 1.0,
"ReinsertionProbability": 1.0,
"SwapProbability": 1.0,
"CreateNumberOfMolecules": 30,
}, {
"MoleculeName": "butane",
"MoleculeDefinition": "TraPPE",
"TranslationProbability": 1.0,
"ReinsertionProbability": 1.0,
"SwapProbability": 1.0,
"CreateNumberOfMolecules": 30,
}],
})
calc.use_parameters(parameters)
# resources
calc.set_max_wallclock_seconds(30 * 60) # 30 min
calc.set_resources({"num_machines": 1, "num_mpiprocs_per_machine": 1})
calc.set_withmpi(False)
#calc.set_queue_name("serial")
if submit:
calc.store_all()
calc.submit()
print(("submitted calculation; calc=Calculation(uuid='{}') # ID={}"\
.format(calc.uuid,calc.dbnode.pk)))
else:
subfolder = calc.submit_test()[0]
path = os.path.relpath(subfolder.abspath)
print("submission test successful")
print(("Find remote folder in {}".format(path)))
print("In order to actually submit, add '--submit'")
def main(codelabel, block_pockets):
code = test_and_get_code(codelabel, expected_code_type='raspa')
options_dict = {
"resources": {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
},
"max_wallclock_seconds": 3 * 60 * 60,
}
options = ParameterData(dict=options_dict)
params_dict = {
"GeneralSettings": {
"SimulationType": "MonteCarlo",
"NumberOfCycles": 2000,
"NumberOfInitializationCycles": 2000,
"PrintEvery": 1000,
"Forcefield": "GenericMOFs",
"EwaldPrecision": 1e-6,
"CutOff": 12.0,
"Framework": 0,
"UnitCells": "1 1 1",
"HeliumVoidFraction": 0.149,
"ExternalTemperature": 300.0,
"ExternalPressure": 5e5,
},
"Component": [{
"MoleculeName": "methane",
"MoleculeDefinition": "TraPPE",
"TranslationProbability": 0.5,
"ReinsertionProbability": 0.5,
"SwapProbability": 1.0,
"CreateNumberOfMolecules": 0,
}],
}
parameters = ParameterData(dict=params_dict)
# structure
pwd = os.path.dirname(os.path.realpath(__file__))
structure = CifData(file=pwd + '/test_raspa_attach_file/TCC1RS.cif')
# block pockets
bp = load_node(block_pockets)
submit(
RaspaConvergeWorkChain,
code=code,
structure=structure,
parameters=parameters,
block_component_0=bp,
options=options,
_label='MyFirstWokchain',
)
def run_fleur_benchmark(code, inp_files_folder_path_list,
wf_para_base_dict_list):
"""
Executes fleur_scf_wcs for every path given in the inp_files_folder_path_list.
resources and so on are specificed in the dictionaries in the nested wf_para_base_dict_list (if you want multiple runs for that system).
designed for running benchmarks from fleur input files.
"""
# get the code
# load the system (load an inp.xml file from the disk)
# launch scf_wc on given systems
all_res = []
if len(inp_files_folder_path_list) != len(wf_para_base_dict_list):
print(
'Input error: for every input folder path given you have to specify a scf workchian paranode! I abort.'
)
return None
code_node = test_and_get_code(code, 'fleur.fleur')
#if isinstance(code, Code):
# code_node = code
#else:
# code_node = Code.get_from_string(code)
# create a fleurinp for each
for i, path in enumerate(inp_files_folder_path_list):
files = os.listdir(path)
inpfiles = []
for name in files:
inpfiles.append(os.path.join(path, name))
if inpfiles:
fleurinp = FleurinpData(files=inpfiles)
structure = fleurinp.get_structuredata_nwf() #fleurinp)
formula = structure.get_formula()
else:
print(('No files found in {}'.format(path)))
continue
scf_para = wf_para_base_dict_list[i]
print(scf_para)
label = 'fleur_scf_benchmark_run_{}'.format(formula)
description = 'Fleur benchmark run on system {} with resources {}'.format(
formula, scf_para['resources'])
print(('submitting {}'.format(label)))
res = submit(FleurScfWorkChain,
wf_parameters=Dict(dict=scf_para),
fleurinp=fleurinp,
fleur=code_node,
_label=label,
_description=description)
all_res.append(res)
return all_res
def main(codename, cp2k_calculation_pk, submit):
"""Command line interface for testing and submitting calculations.
Usage: ./cli.py CODENAME CP2K_CALCULATION
CODENAME from "verdi code setup"
COMPUTER_NAME from "verdi calculation list -a"
This script extends submit.py, adding flexibility in the selected code/computer.
"""
code = test_and_get_code(codename, expected_code_type='ddec')
# input parameters
parameters = ParameterData(dict=input_dict)
# set up calculation
calc = code.new_calc()
calc.label = "aiida_plugin_template computes 2*3"
calc.description = "Test job submission with the aiida_plugin_template plugin"
calc.set_max_wallclock_seconds(30 * 60) # 30 min
calc.set_withmpi(False)
calc.set_resources({"num_machines": 1})
calc.use_parameters(parameters)
# use cp2k calculations
cp2k_calc = load_node(int(cp2k_calculation_pk))
calc.use_charge_density_folder(cp2k_calc.out.remote_folder)
if submit:
calc.store_all()
calc.submit()
print("submitted calculation; calc=Calculation(uuid='{}') # ID={}"\
.format(calc.uuid,calc.dbnode.pk))
else:
subfolder, script_filename = calc.submit_test()
path = os.path.relpath(subfolder.abspath)
print("submission test successful")
print("Find remote folder in {}".format(path))
print("In order to actually submit, add '--submit'")
"MoleculeName" : "methane",
"MoleculeDefinition" : "TraPPE",
"MolFraction" : 1.0,
"TranslationProbability" : 1.0,
"RotationProbability" : 1.0,
"ReinsertionProbability" : 1.0,
"SwapProbability" : 1.0,
"CreateNumberOfMolecules" : 0,
}],
})
# Calculation resources
options = {
"resources": {
"num_machines": 1, # run on 1 node
"tot_num_mpiprocs": 1, # use 1 process
"num_mpiprocs_per_machine": 1,
},
"max_wallclock_seconds": 1 * 60 * 60, # 1h walltime
"max_memory_kb": 2000000, # 2GB memory
"queue_name": "molsim", # slurm partition to use
"withmpi": False, # we run in serial mode
}
submit(RaspaCalculation.process(),
code=test_and_get_code("raspa@bazis", expected_code_type='raspa'),
structure=load_node("<uuid>"),
parameters=parameters,
_options=options
)
from aiida.backends import settings
if not is_dbenv_loaded():
load_dbenv(profile=settings.AIIDADB_PROFILE)
from aiida.common.example_helpers import test_and_get_code # noqa
from aiida.orm.data.structure import StructureData # noqa
from aiida.orm.data.parameter import ParameterData # noqa
from aiida.orm.data.singlefile import SinglefileData # noqa
# ==============================================================================
if len(sys.argv) != 2:
print("Usage: test_dft.py <code_name>")
sys.exit(1)
codename = sys.argv[1]
code = test_and_get_code(codename, expected_code_type='cp2k')
print("Testing CP2K ENERGY on H2O (DFT)...")
# calc object
calc = code.new_calc()
# structure
atoms = ase.build.molecule('H2O')
atoms.center(vacuum=2.0)
structure = StructureData(ase=atoms)
calc.use_structure(structure)
# parameters
parameters = ParameterData(
dict={
"Framework": 0,
"UnitCells": "1 1 1",
"ExternalTemperature": 298.0,
},
"Component": [{
"MoleculeName": "tip4p",
"MoleculeDefinition": "tip4p",
"TranslationProbability": 0.5,
"RotationProbability": 0.5,
"ReinsertionProbability": 0.5,
"SwapProbability": 1.0,
"CreateNumberOfMolecules": 0,
}],
})
zeopp_code = test_and_get_code('zeopp@fidis',
expected_code_type='zeopp.network')
raspa_code = test_and_get_code('raspa2@fidis', expected_code_type='raspa')
for cif in cifs:
for pressure in pressures:
structure = CifData(file=cif)
submit(
ResubmitGCMC,
structure=structure,
zeopp_probe_radius=Float(probe_radius),
number_runs=Float(number_runs),
pressure=Float(pressure),
zeopp_code=zeopp_code,
_zeopp_options=zr_options,
zeopp_atomic_radii=atomic_radii,
raspa_code=raspa_code,
try:
codename = sys.argv[2]
except IndexError:
codename = None
# If True, load the pseudos from the family specified below
# Otherwise, use static files provided
auto_pseudos = True
queue = None
# queue = "Q_aries_free"
settings = None
#####
code = test_and_get_code(codename, expected_code_type='quantumespresso.neb')
cell = [
[
4.0,
0.,
0.,
],
[
0.,
4.0,
0.,
],
[
0.,
0.,
raise IndexError
except IndexError:
print(('The first parameter can only be either ' '--send or --dont-send'), file=sys.stderr)
sys.exit(1)
try:
codename = sys.argv[2]
except IndexError:
codename = None
queue = None
# queue = "th1_small"
settings = None
#####
code = test_and_get_code(codename, expected_code_type='fleur_inp.fleurinputgen')
bohr_a_0 = 0.52917721092 # A
# Cr_delta_inp
a = 5.425405929900 * bohr_a_0
cell = [[a, 0., 0.], [0., a, 0.], [0., 0., a]]
Cr = StructureData(cell=cell)
Cr.append_atom(position=(0., 0., 0.), symbols='Cr', name='Cr1')
pos2 = rel_to_abs((1. / 2., 1. / 2., 1. / 2.), cell)
Cr.append_atom(position=pos2, symbols='Cr', name='Cr2')
Crp = Dict(
dict={
'title': 'Cr, bcc chromium, bulk, delta project',
'atom1': {
'element': 'Cr',
'id': '24.0',
structure = load_node(int(structure_pk))
try:
pw_codename = sys.argv[2]
except IndexError:
print >> sys.stderr, "The second parameter must be the pw code name"
sys.exit(1)
try:
ph_codename = sys.argv[3]
except IndexError:
print >> sys.stderr, "The third parameter must be the ph code name"
sys.exit(1)
# validate codes and pseudopotential family
test_and_get_code(pw_codename,'quantumespresso.pw')
test_and_get_code(ph_codename,'quantumespresso.ph')
validate_upf_family(pseudo_family, structure.get_kind_names())
try:
wien2k_EOS_pk = sys.argv[4]
except IndexError:
print >> sys.stderr, ("The fourth parameter must be the pk of the Wien2k SinglefileData")
sys.exit(1)
try:
band_kpoints_pk = sys.argv[5]
except IndexError:
print >> sys.stderr, ("The fifth parameter must be the pk of the KpointsData used for band structure convergence")
sys.exit(1)
except IndexError:
print >> sys.stderr, ("The first parameter can only be either "
"--send or --dont-send")
sys.exit(1)
try:
codename = sys.argv[2]
except IndexError:
codename = None
queue = None
#queue = "Q_aries_free"
settings = None
#####
code = test_and_get_code(codename, expected_code_type='nwchem.basic')
alat = 4. # angstrom
cell = [
[
alat,
0.,
0.,
],
[
0.,
alat,
0.,
],
[
0.,
print >> sys.stderr, 'Parent_id not an integer: {}'.format(parent_id)
sys.exit(1)
try:
nnkp_file_id = int(nnkp_file_id)
except ValueError:
print >> sys.stderr, 'nnkp_file_id not an integer: {}'.format(nnkp_file_id)
sys.exit(1)
nnkp_file = load_node(nnkp_file_id)
if not isinstance(nnkp_file, DataFactory('singlefile')):
print >> sys.stderr, 'The provided nnkp_file is not an SinglefileData: {}'.format(
nnkp_file_id)
sys.exit(1)
code = test_and_get_code(codename,
expected_code_type='quantumespresso.pw2wannier90')
computer = code.get_remote_computer()
parameters = ParameterData(dict={
'INPUTPP': {
'write_unk': True,
'write_amn': True,
'write_mmn': True,
},
})
parentcalc = load_node(parent_id)
# calc = code.new_calc(computer=computer)
calc = code.new_calc()
else:
raise IndexError
except IndexError:
print >> sys.stderr, ("The first parameter can only be either "
"--send or --dont-send")
sys.exit(1)
try:
codename = sys.argv[2]
except IndexError:
codename = None
queue = None
settings = None
code = test_and_get_code(codename, expected_code_type='quantumespresso.pw')
max_seconds = 600
kpoints = KpointsData()
kpoints_mesh = 4
kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh])
from aiida.tools.dbimporters.plugins.cod import CodDbImporter
from aiida.orm.data.cif import parse_formula
codi = CodDbImporter()
launched_calcs = {}
## SQL query, executed in the COD database:
## select file, formula
## from data
codename = sys.argv.pop(0)
elif arg == '--arg':
argkey = None
argval = None
if '=' in sys.argv[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)
code = test_and_get_code(codename, expected_code_type="codtools.ciffilter")
cif = None
if len(files) == 1:
cif = CifData(file=os.path.abspath(files[0]))
else:
raise ValueError("Please specify a single CIF file")
parameters = ParameterData(dict=options)
computer = Computer.get(Computer.list_names()[0])
calc = code.new_calc()
calc.label = "Test cod-tools cif_molecule"
calc.description = "Test calculation with the cod-tools cif_molecule"
calc.set_max_wallclock_seconds(30 * 60) # 30 min
calc.set_resources({"num_machines": 1,
"HeliumVoidFraction": 0.0,
"ExternalTemperature": 298.0,
"ExternalPressure": 58e4,
},
"Component": [{
"MoleculeName": "CO2",
"MoleculeDefinition": "TraPPE",
"TranslationProbability": 0.5,
"RotationProbability": 0.5,
"ReinsertionProbability": 0.5,
"SwapProbability": 1.0,
"CreateNumberOfMolecules": 0,
}],
})
zeopp_code = test_and_get_code('zeopp@deneb',
expected_code_type='zeopp.network')
raspa_code = test_and_get_code('raspa@deneb', expected_code_type='raspa')
pressures = ArrayData()
pressures.set_array("pressures", np.array([0.01e5]))
submit(
Isotherm,
structure=structure,
probe_radius=Float(1.525),
pressures=pressures,
min_cell_size=Float(10.0),
zeopp_code=zeopp_code,
_zeopp_options=zr_options,
raspa_code=raspa_code,
raspa_parameters=raspa_parameters,
_raspa_options=zr_options,
from aiida.backends import settings
if not is_dbenv_loaded():
load_dbenv(profile=settings.AIIDADB_PROFILE)
from aiida.common.example_helpers import test_and_get_code
from aiida.orm.data.cif import CifData
from aiida.orm.data.parameter import ParameterData
from aiida.orm.data.singlefile import SinglefileData
# ==============================================================================
if len(sys.argv) != 3:
print("Usage: test_raspa.py <code_name> parent_calc_pk")
sys.exit(1)
codename = sys.argv[1]
code = test_and_get_code(codename, expected_code_type='raspa')
parent_calc = int(sys.argv[2])
print("Testing RASPA...")
# calc object
calc = code.new_calc()
# parameters
parameters = ParameterData(
dict={
"GeneralSettings": {
"SimulationType": "MonteCarlo",
"NumberOfCycles": 2000,
"NumberOfInitializationCycles": 2000,
codename = sys.argv.pop(0)
elif arg == '--arg':
argkey = None
argval = None
if '=' in sys.argv[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)
code = test_and_get_code(codename, expected_code_type="codtools.cifcellcontents")
cif = None
if len(files) == 1:
cif = CifData(file=os.path.abspath(files[0]))
else:
raise ValueError("Please specify a single CIF file")
parameters = ParameterData(dict=options)
computer = Computer.get(Computer.list_names()[0])
calc = code.new_calc()
calc.label = "Test cod-tools cif_cell_contents"
calc.description = "Test calculation with the cod-tools cif_cell_contents"
calc.set_max_wallclock_seconds(30 * 60) # 30 min
calc.set_resources({"num_machines": 1,
settings_dict = {'also_bands': True}
settings = ParameterData(dict=settings_dict)
# calc.label = "Test QE pw.x"
# calc.description = "Test calculation with the Quantum ESPRESSO pw.x code"
# Valid only for Slurm and PBS (using default values for the
# number_cpus_per_machine), change for SGE-like schedulers
JobCalc = PwCalculation.process()
# Inputs
inputs = JobCalc.get_inputs_template()
inputs.structure = s
inputs.parameters = parameters
inputs.kpoints = kpoints
inputs.code = test_and_get_code(codename,
expected_code_type='quantumespresso.pw')
# Calculation options
options = inputs._options
options.max_wallclock_seconds = 30 * 60 # 30 min
options.resources = {"num_machines": 1, "num_mpiprocs_per_machine": 8}
options.custom_scheduler_commands = u"#SBATCH --account=ch3"
if run_in_serial_mode:
options.withmpi = False
if queue is not None:
options.queue_name = queue
if settings is not None:
inputs.settings = settings
# if auto_pseudos:
submit_test = False
else:
raise IndexError
except IndexError:
print >> sys.stderr, ("The first parameter can only be either "
"--send or --dont-send")
sys.exit(1)
#####- Code ----------------------------------------------------
try:
codename = sys.argv[2]
except IndexError:
codename = 'go-2.0.0@cm135'
code = test_and_get_code(codename, expected_code_type='gollum.gollum')
#####- Set up calculation object -------------------------------
calc = code.new_calc()
calc.label = "Test Gollum. Spin-polarized chain"
calc.description = "Test calculation with the Gollum code. Spin-pol chain"
#####- Settings ------------------------------------------------
emname = os.path.realpath(os.path.join(os.path.dirname(__file__),
"../data"))+'/Extended_Molecule'
l1name = os.path.realpath(os.path.join(os.path.dirname(__file__),
"../data"))+'/Lead_1'
l2name = os.path.realpath(os.path.join(os.path.dirname(__file__),
"../data"))+'/Lead_2'
kpoints_wf.append(kmesh)
kpoints.store()
structures_wf.append(struct)
scaled_struct, new_k = scale_structure(kmesh, struct, json_hpc['scale'])
scaled_struct.store()
param = calc.get_inputs_dict()['parameters'].get_attrs()
extras = calc.get_extras()
parameters = set_dict(param, args.json_pw, 1, 1)
pw_parameters = ParameterData(dict=parameters)
pw_parameters.store()
pw_parameters_wf.append(pw_parameters)
hpc_parameters = ParameterData(dict=json_hpc)
hpc_parameters.store()
code = test_and_get_code(args.code,
expected_code_type='quantumespresso.pw')
UpfData.get_upf_group(pseudo_family)
hpc_workflow_params.update({
'pw_codename_' + str(count): args.code,
'structure_' + str(count): scaled_struct,
'hpc_params_' + str(count): hpc_parameters,
'pseudo_family_' + str(count): pseudo_family,
'kpoints_' + str(count): new_k,
'pw_parameters_' + str(count): pw_parameters,
'extras_' + str(count): extras
})
keys.append(count)
count += 1
wf_params = {}
bench = BenchWorkflow()
cp2k_options = {
"resources": {
"num_machines": 1,
},
"max_wallclock_seconds": 1 * 60 * 60,
}
ddec_options = {
"resources": {
"num_machines": 1,
},
"max_wallclock_seconds": 1 * 60 * 60,
"withmpi": False,
}
cp2k_code = test_and_get_code('cp2k_6.1_18464@daint-s746',
expected_code_type='cp2k')
ddec_code = test_and_get_code('chargemol_09_26_2017@daint-s746',
expected_code_type='ddec')
ddec_params = ParameterData(
dict={
"net charge":
0.0,
"charge type":
"DDEC6",
"periodicity along A, B, and C vectors": [
True,
True,
True,
],
"compute BOs":
except IndexError:
print >> sys.stderr, ("The first parameter can only be either "
"--send or --dont-send")
sys.exit(1)
try:
codename = sys.argv[2]
except IndexError:
codename = None
queue = None
#queue = "Q_aries_free"
settings = None
#####
code = test_and_get_code(codename, expected_code_type='nwchem.nwcpymatgen')
calc = code.new_calc()
calc.label = "Test NWChem"
calc.description = "Test calculation with the NWChem SCF code"
calc.set_max_wallclock_seconds(30 * 60) # 30 min
calc.set_resources({"num_machines": 1})
if queue is not None:
calc.set_queue_name(queue)
parameters = ParameterData(
dict={
'tasks': [{
'theory': 'scf',
'basis_set': {
},
'GEO_OPT': {
'MAX_ITER': 5,
},
'CELL_OPT': {
'MAX_ITER': 5,
},
},
}
ddec_options = {
"resources": {
"num_machines": 1,
},
"max_wallclock_seconds": 1 * 60 * 60 / 2,
"withmpi": False,
}
cp2k_parameters = ParameterData(dict=params_dict)
cp2k_code = test_and_get_code('cp2k@fidis-debug', expected_code_type='cp2k')
ddec_code = test_and_get_code('ddec@fidis-debug', expected_code_type='ddec')
submit(
Cp2kGeoOptDdecWorkChain,
structure=structure,
cp2k_code=cp2k_code,
cp2k_parameters=cp2k_parameters,
_cp2k_options=cp2k_options,
ddec_code=ddec_code,
_ddec_options=ddec_options,
_label='MyFirstWokchain',
_guess_multiplicity=True,
)
structure = StructureData(ase=atoms)
structure.label = 'H2O'
structure.store()
options_dict = {
"resources": {
"num_machines": 1,
"num_mpiprocs_per_machine": 2,
},
"max_wallclock_seconds": 3 * 60 * 60,
}
options = ParameterData(dict=options_dict)
params_dict = {
'FORCE_EVAL': {
'DFT': {
'UKS': True,
},
},
}
parameters = ParameterData(dict=params_dict)
code = test_and_get_code('cp2k@localhost', expected_code_type='cp2k')
submit(
Cp2kGeoOptWorkChain,
code=code,
structure=structure,
parameters=parameters,
options=options,
_label='MyFirstWokchain',
)
"max_wallclock_seconds": 1 * 60 * 60,
'prepend_text': '#SBATCH --partition=debug',
}
options = ParameterData(dict=options_dict)
params_dict = {
'MOTION': {
'MD': {
'STEPS': 5,
},
'GEO_OPT': {
'MAX_ITER': 5,
},
'CELL_OPT': {
'MAX_ITER': 5,
},
},
}
parameters = ParameterData(dict=params_dict)
code = test_and_get_code('cp2k-5.1@fidis', expected_code_type='cp2k')
submit(
Cp2kRobustGeoOptWorkChain,
code=code,
structure=structure,
parameters=parameters,
options=options,
_label='MyFirstWokchain',
_guess_multiplicity=True,
)
print(('The first parameter can only be either '
'--send or --dont-send'),
file=sys.stderr)
sys.exit(1)
try:
codename = sys.argv[2]
except IndexError:
codename = None
queue = None
# queue = "th1_small"
settings = None
#####
code = test_and_get_code(codename, expected_code_type='fleur.fleur')
#TODO: how to make smart path?
# get where tests folder is, then relative path
inpxmlfile = '/usr/users/iff_th1/broeder/aiida/github/aiida_fleur_plugin/tests/inp_xml_files/Fe_bctXML/files/inp.xml'
symout = '/usr/users/iff_th1/broeder/aiida/github/aiida_fleur_plugin/tests/inp_xml_files/Fe_bctXML/files/sym.out'
fleurinp = FleurinpData(files=[inpxmlfile, symout])
print(fleurinp.files)
## For remote codes, it is not necessary to manually set the computer,
## since it is set automatically by new_calc
#computer = code.get_remote_computer()
#calc = code.new_calc(computer=computer)
calc = code.new_calc()
calc.label = 'Fe_bct Fleur test'
from aiida.common.example_helpers import test_and_get_code # noqa
from aiida.orm.data.structure import StructureData # noqa
from aiida.orm.data.parameter import ParameterData # noqa
from aiida.orm.data.base import Str
from aiida.work.run import submit
from ase.io import read
from cp2k import Cp2kDftBaseWorkChain
atoms = read('Fe-MOF-74_h111.xyz')
atoms.cell = [[6.96775, 0.00000, 0.00000], [-2.33067, 15.22261, 0.00000],
[-2.32566, -7.57517, 13.22945]]
structure = StructureData(ase=atoms)
structure.store()
options_dict = {
"resources": {
"num_machines": 2,
"num_mpiprocs_per_machine": 12,
},
"max_wallclock_seconds": 8 * 60 * 60,
}
options = ParameterData(dict=options_dict)
code = test_and_get_code('cp2k@daint', expected_code_type='cp2k')
submit(
Cp2kDftBaseWorkChain,
code=code,
structure=structure,
options=options,
)
"--send or --dont-send")
sys.exit(1)
try:
codename = sys.argv[2]
except IndexError:
codename = 'Siesta-4.0@rinaldo'
# If True, load the pseudos from the family specified below
# Otherwise, use static files provided
auto_pseudos = True
queue = None
settings = None
code = test_and_get_code(codename, expected_code_type='siesta.siesta')
alat = 5.430 # angstrom
cell = [
[
0.5 * alat,
0.5 * alat,
0.,
],
[
0.,
0.5 * alat,
0.5 * alat,
],
[
0.5 * alat,
def start(self):
"""
Checks the parameters
"""
self.append_to_report("Checking input parameters")
mandatory_pw_keys = [
('structure', StructureData,
"the structure (a previously stored StructureData object)"),
('pseudo_family', basestring, 'the pseudopotential family'),
('pw_kpoints', KpointsData,
'A KpointsData object with the kpoint mesh used by PWscf'),
#('pw_calculation_set',dict,'A dictionary with resources, walltime, ...'),
('pw_parameters', dict, "A dictionary with the PW input parameters"
),
]
mandatory_ph_keys = [
('ph_qpoints', KpointsData,
'A KpointsData object with the kpoint mesh used by PWscf'),
('ph_calculation_set', dict,
'A dictionary with resources, walltime, ...'),
('ph_parameters', dict,
"A dictionary with the PH input parameters"),
]
mandatory_dispersion_keys = [
('dispersion_calculation_set', dict,
'A dictionary with resources, walltime, ...'),
]
main_params = self.get_parameters()
# validate the codes
for kind, key in [
['quantumespresso.pw', 'pw_codename'],
['quantumespresso.ph', 'ph_codename'],
['quantumespresso.q2r', 'dispersion_q2r_codename'],
['quantumespresso.matdyn', 'dispersion_matdyn_codename'],
]:
try:
test_and_get_code(main_params[key], kind, use_exceptions=True)
except KeyError:
# none of the codes is always required
pass
# case of restart from phonon calculation
if 'ph_calculation' in main_params:
if isinstance(main_params['ph_calculation'], PhCalculation):
helpers.validate_keys(main_params, mandatory_dispersion_keys)
self.next(self.run_q2r)
return
else:
raise TypeError("parameter 'ph_calculation' should be a "
"PhCalculation")
# case of restart from phonon folder
if 'ph_folder' in main_params:
if isinstance(main_params['ph_folder'], DataFactory('folder')):
helpers.validate_keys(main_params, mandatory_dispersion_keys)
self.next(self.run_q2r)
return
else:
raise TypeError("parameter 'ph_folder' should be a FolderData")
# validate phonon keys
helpers.validate_keys(main_params, mandatory_ph_keys)
if 'pw_calculation' in main_params:
if isinstance(main_params['pw_calculation'], PwCalculation):
# if pw is a calculation, launch directly from the PH step
self.next(self.run_ph)
return
else:
raise TypeError("parameter 'pw_calculation' should be a "
"PwCalculation")
# validate Pw keys
helpers.validate_keys(main_params, mandatory_pw_keys)
# start from Pw calculation
self.next(self.run_pw)
