def setUp(self):
self.comp = Computer.get('comp')
self.runner = CliRunner()
self.this_folder = os.path.dirname(__file__)
self.this_file = os.path.basename(__file__)
self.cli_runner = CliRunner()
def setUp(self):
from aiida.orm import Computer
self.comp = Computer.get('comp')
self.runner = CliRunner()
self.this_folder = os.path.dirname(__file__)
self.this_file = os.path.basename(__file__)
def get_computer(name='localhost'):
"""Get local computer.
Sets up local computer with 'name' or reads it from database,
if it exists.
:param name: Name of local computer
:return: The computer node
:rtype: :py:class:`aiida.orm.Computer`
"""
from aiida.orm import Computer
from aiida.common.exceptions import NotExistent
try:
computer = Computer.get(name)
except NotExistent:
computer = Computer(
name=name,
description='localhost computer set up by aiida_gudhi tests',
hostname='localhost',
workdir=tempfile.mkdtemp(),
transport_type='local',
scheduler_type='direct',
enabled_state=True)
computer.store()
return computer
def set_deneb_defaults(options_template):
from aiida.orm import Computer
options_template.max_wallclock_seconds = DEFAULT_OPTIONS[
'max_wallclock_seconds']
options_template.resources = DEFAULT_OPTIONS['resources']
options_template.queue_name = DEFAULT_OPTIONS['queue_name']
options_template.computer = Computer.get(DEFAULT_OPTIONS['computer'])
def test_mixed(self):
from aiida.orm import Computer
os.environ['VISUAL'] = 'sleep 1; vim -cwq'
os.environ['EDITOR'] = 'sleep 1; vim -cwq'
label = 'mixed_computer'
options_dict = generate_setup_options_dict(
replace_args={'label': label})
options_dict_full = options_dict.copy()
options_dict.pop('non-interactive', 'None')
non_interactive_options_dict = {}
non_interactive_options_dict['enabled'] = None
non_interactive_options_dict['prepend-text'] = options_dict.pop(
'prepend-text')
non_interactive_options_dict['append-text'] = options_dict.pop(
'append-text')
non_interactive_options_dict['shebang'] = options_dict.pop('shebang')
non_interactive_options_dict['scheduler'] = options_dict.pop(
'scheduler')
# In any case, these would be managed by the visual editor
user_input = "\n".join(
generate_setup_options_interactive(options_dict))
options = generate_setup_options(non_interactive_options_dict)
result = self.runner.invoke(setup_computer, options, input=user_input)
self.assertIsNone(
result.exception,
msg="There was an unexpected exception. Output: {}".format(
result.output))
new_computer = Computer.get(label)
self.assertIsInstance(new_computer, Computer)
self.assertEqual(new_computer.description,
options_dict_full['description'])
self.assertEqual(new_computer.hostname, options_dict_full['hostname'])
self.assertEqual(new_computer.get_transport_type(),
options_dict_full['transport'])
self.assertEqual(new_computer.get_scheduler_type(),
options_dict_full['scheduler'])
self.assertTrue(new_computer.is_enabled())
self.assertEqual(new_computer.get_mpirun_command(),
options_dict_full['mpirun-command'].split())
self.assertEqual(new_computer.get_shebang(),
options_dict_full['shebang'])
self.assertEqual(new_computer.get_workdir(),
options_dict_full['work-dir'])
self.assertEqual(new_computer.get_default_mpiprocs_per_machine(),
int(options_dict_full['mpiprocs-per-machine']))
# For now I'm not writing anything in them
self.assertEqual(new_computer.get_prepend_text(),
options_dict_full['prepend-text'])
self.assertEqual(new_computer.get_append_text(),
options_dict_full['append-text'])
def test_data_loaded(self):
"""
Check that the data is indeed in the DB when calling load_node
"""
from aiida.orm import Computer
from aiida.orm import load_node
self.assertTrue(is_dbenv_loaded())
self.assertEqual(load_node(self.data_pk).uuid, self.data.uuid)
self.assertEqual(Computer.get('localhost').uuid, self.computer.uuid)
def test_delete(self):
from aiida.orm import Computer
new_comp = Computer(name='aaa',
hostname='aaa',
transport_type='local',
scheduler_type='pbspro',
workdir='/tmp/aiida')
new_comp.store()
comp_pk = new_comp.pk
check_computer = Computer.get(comp_pk)
self.assertEquals(comp_pk, check_computer.pk)
from aiida.orm.computer import delete_computer
delete_computer(pk=comp_pk)
with self.assertRaises(NotExistent):
Computer.get(comp_pk)
def setUp(self):
comp = Computer.get('comp')
self.r = RemoteData()
p = tempfile.mkdtemp()
self.r.set_remote_path(p)
with open(p + '/file.txt', 'w') as f:
f.write("test string")
self.r.set_computer(comp)
self.r.store()
self.cli_runner = CliRunner()
def test_duplicate(cmd_test_env):
"""Test the duplicate command"""
from aiida.orm import Computer, Code
_ = cmd_test_env
runner = CliRunner()
runner.invoke(duplicate_fe, ["-Y", "localhost"], catch_exceptions=False)
assert Computer.get(label='localhost-fw')
assert Computer.get(
label='localhost-fw').scheduler_type == "fireworks_scheduler.default"
runner.invoke(duplicate_fe, ["-Y", "localhost", "--suffix", 'fe'],
catch_exceptions=False)
assert Computer.get(label='localhost-fe')
runner.invoke(duplicate_fe,
["-Y", "localhost", "--suffix", 'fc', '--include-codes'],
catch_exceptions=False)
assert Computer.get(label='localhost-fc')
assert Code.get_from_string("bash@localhost-fc")
runner.invoke(
duplicate_fe,
["-Y", "localhost", "--job-should-keep-env", "--suffix", 'env'],
catch_exceptions=False)
assert Computer.get(label='localhost-env')
assert Computer.get(
label='localhost-env').scheduler_type == "fireworks_scheduler.keepenv"
def generate_calc(self):
from aiida.orm import Code, Computer, CalculationFactory
from aiida.common.datastructures import calc_states
CustomCalc = CalculationFactory('simpleplugins.templatereplacer')
computer = Computer.get("localhost")
calc = CustomCalc(computer=computer, withmpi=True)
calc.set_resources({"num_machines": 1, "num_mpiprocs_per_machine": 1})
calc.store()
calc._set_state(calc_states.FINISHED)
return calc
def generate_calc():
from aiida.orm import Code, Computer, CalculationFactory
from aiida.common.datastructures import calc_states
CustomCalc = CalculationFactory('simpleplugins.templatereplacer')
computer = Computer.get("localhost")
calc = CustomCalc(computer=computer, withmpi=True)
calc.set_resources({"num_machines": 1, "num_mpiprocs_per_machine": 1})
calc.store()
calc._set_state(calc_states.FINISHED)
return calc
def _set_computer_string(self, string):
"""
Set the computer starting from a string.
"""
from aiida.common.exceptions import ValidationError, NotExistent
from aiida.orm import Computer as AiidaOrmComputer
try:
computer = AiidaOrmComputer.get(string)
except NotExistent:
raise ValidationError("Computer with name '{}' not found in "
"DB".format(string))
self._computer_validator(computer)
self.computer = computer
def setUp(self):
from aiida.orm import Computer, Code
self.comp = Computer.get('comp')
try:
code = Code.get_from_string('code')
except NotExistent:
code = Code(
input_plugin_name='simpleplugins.arithmetic.add',
remote_computer_exec=[self.comp, '/remote/abs/path'],
)
code.label = 'code'
code.store()
self.code = code
self.runner = CliRunner()
def test_noninteractive_optional_default_mpiprocs(self):
"""
Check that if is ok not to specify mpiprocs-per-machine
"""
from aiida.orm import Computer
options_dict = generate_setup_options_dict(
{'label': 'computer_default_mpiprocs'})
options_dict.pop('mpiprocs-per-machine')
options = generate_setup_options(options_dict)
result = self.runner.invoke(setup_computer, options)
self.assertIsNone(result.exception, result.output[-1000:])
new_computer = Computer.get(options_dict['label'])
self.assertIsInstance(new_computer, Computer)
self.assertIsNone(new_computer.get_default_mpiprocs_per_machine())
def test_noninteractive_optional_default_mpiprocs_2(self):
"""
Check that if is the specified value is zero, it means unspecified
"""
from aiida.orm import Computer
options_dict = generate_setup_options_dict(
{'label': 'computer_default_mpiprocs_2'})
options_dict['mpiprocs-per-machine'] = 0
options = generate_setup_options(options_dict)
result = self.runner.invoke(setup_computer, options)
self.assertIsNone(result.exception, result.output[-1000:])
new_computer = Computer.get(options_dict['label'])
self.assertIsInstance(new_computer, Computer)
self.assertIsNone(new_computer.get_default_mpiprocs_per_machine())
def run_wswannier():
input_archive = get_input_archive()
code = Code.get_from_string('Wannier90_2.1.0')
calc = CalculationFactory('vasp.wswannier')()
calc.use_code(code)
# Monch
calc.set_resources(dict(num_machines=1, tot_num_mpiprocs=1))
calc.set_computer(Computer.get('Monch'))
calc.set_queue_name('express_compute')
calc.use_data(input_archive)
# hard-code parameters for InSb test
calc.use_settings(
ParameterData(dict=dict(
num_wann=14,
num_bands=36,
dis_num_iter=1000,
num_iter=0,
dis_win_min=-4.5,
dis_win_max=16.,
dis_froz_min=-4.,
dis_froz_max=6.5,
write_hr=True,
use_ws_distance=True,
write_xyz=True,
write_tb=True,
projections=[['In : s; px; py; pz'], ['Sb : px; py; pz']],
spinors=True,
unit_cell_cart=[[0., 3.2395, 3.2395], [3.2395, 0., 3.2395],
[3.2395, 3.2395, 0.]],
bands_plot=True,
atoms_cart=[['In', 0., 0., 0.], ['Sb', 1.61975, 1.61975, 1.61975]],
mp_grid='6 6 6',
kpoints=[
list(reversed(x)) for x in itertools.
product((0., 1 / 6, 2 / 6, 0.5, -2 / 6, -1 / 6), repeat=3)
],
kpoint_path=[
['G', 0, 0, 0, 'L', 0.5, 0.5, 0.5],
])))
calc.store_all()
calc.submit()
print('Submitted calculation', calc.pk)
def test_noninteractive_enabled(self):
"""
I check what happens if the computer should be enabled, explicitly setting
--enabled.
I only check the changes, the rest is already checked in ``test_noninteractive()``.
"""
from aiida.orm import Computer
options_dict = generate_setup_options_dict(
{'label': 'computer_enabled'})
options_dict.pop('disabled', None) # Make sure 'disabled' is not there
options_dict['enabled'] = None # Activate --enabled
options = generate_setup_options(options_dict)
result = self.runner.invoke(setup_computer, options)
self.assertIsNone(result.exception, result.output[-1000:])
new_computer = Computer.get(options_dict['label'])
self.assertIsInstance(new_computer, Computer)
self.assertTrue(new_computer.is_enabled())
def get_computer(name='localhost'):
"""Setup localhost computer"""
from aiida.orm import Computer
from aiida.common.exceptions import NotExistent
try:
computer = Computer.get(name)
except NotExistent:
import tempfile
computer = Computer(
name=name,
description='localhost computer set up by aiida_gudhi tests',
hostname='localhost',
workdir=tempfile.mkdtemp(),
transport_type='local',
scheduler_type='direct',
enabled_state=True)
computer.store()
return computer
def test_noninteractive(self):
"""
Main test to check if the non-interactive command works
"""
from aiida.orm import Computer
options_dict = generate_setup_options_dict()
options = generate_setup_options(options_dict)
result = self.runner.invoke(setup_computer, options)
self.assertIsNone(result.exception, result.output[-1000:])
new_computer = Computer.get(options_dict['label'])
self.assertIsInstance(new_computer, Computer)
self.assertEqual(new_computer.description, options_dict['description'])
self.assertEqual(new_computer.hostname, options_dict['hostname'])
self.assertEqual(new_computer.get_transport_type(),
options_dict['transport'])
self.assertEqual(new_computer.get_scheduler_type(),
options_dict['scheduler'])
self.assertTrue(new_computer.is_enabled())
self.assertEqual(new_computer.get_mpirun_command(),
options_dict['mpirun-command'].split())
self.assertEqual(new_computer.get_shebang(), options_dict['shebang'])
self.assertEqual(new_computer.get_workdir(), options_dict['work-dir'])
self.assertEqual(new_computer.get_default_mpiprocs_per_machine(),
int(options_dict['mpiprocs-per-machine']))
self.assertEqual(new_computer.get_prepend_text(),
options_dict['prepend-text'])
self.assertEqual(new_computer.get_append_text(),
options_dict['append-text'])
# Test that I cannot generate twice a computer with the same label
result = self.runner.invoke(setup_computer, options)
self.assertIsInstance(result.exception, SystemExit)
self.assertIn("already exists", result.output)
###############################
# Set your values here
codename = 'fleur_inpgen_mac'
computer_name = 'local_mac'
#computer_name = 'iff003'
#codename2 = 'fleur_v0.27@iff003'
codename2 = 'fleur_iff003_v0_27@iff003'
#codename2 = 'fleur_mac'
###############################
code = Code.get_from_string(codename)
code2 = Code.get_from_string(codename2)
#JobCalc = FleurinputgenCalculation.process()
computer = Computer.get(computer_name)
s = load_node(14204) #13586)#137)# Be13586, W 137
print s.sites
#print s.cell
parameters = load_node(13496) # Be 13496, W 13161
wf_para = ParameterData(dict={
'relax_runmax': 5,
'density_criterion': 0.0000001,
'max_force_cycle': 9
})
res = fleur_relax_wc.run(wf_parameters=wf_para,
structure=s,
calc_parameters=parameters,
inpgen=code,
from aiida import load_dbenv
load_dbenv()
from aiida.orm import Code, Computer
from aiida.orm.querytool import QueryTool
from aiida.orm.calculation.job.vasp.maker import VaspMaker
import sys
cifname = sys.argv[1]
mkcalc = VaspMaker(structure=cifname)
mkcalc.code = Code.get_from_string('asevasp@monch')
mkcalc.kpoints.set_kpoints_mesh([8, 8, 8])
mkcalc.add_settings(system=mkcalc.structure.filename, npar=8)
mkcalc.recipe = 'test_sc'
mkcalc.computer = Computer.get('monch')
mkcalc.queue = 'dphys_compute'
v5 = mkcalc.new()
v5.set_resources({'num_machines': 8, 'num_mpiprocs_per_machine': 2})
# ~ v5.set_max_memory_kb(8000000)
tag = sys.argv[2]
q = QueryTool()
q.set_class(mkcalc.calc_cls)
q.add_extra_filter('tag', '=', tag)
ql = map(lambda c: c.get_extra('test-nr'), q.run_query())
last_tn = ql and max(ql) or 0
v5.store_all()
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"
sys.exit(1)
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_cod_deposit"
calc.description = "Test deposition with the cod-tools cif_cod_deposit"
calc.set_max_wallclock_seconds(30 * 60) # 30 min
calc.set_resources({"num_machines": 1,
"num_mpiprocs_per_machine": 1})
calc.set_computer(computer)
calc.use_cif(cif)
calc.use_parameters(parameters)
if submit_test:
subfolder, script_filename = calc.submit_test()
print "Test_submit for calculation (uuid='{}')".format(
def query_jobcalculations_by_computer_user_state(
self,
state,
computer=None,
user=None,
only_computer_user_pairs=False,
only_enabled=True,
limit=None):
# Here I am overriding the implementation using the QueryBuilder:
"""
Filter all calculations with a given state.
Issue a warning if the state is not in the list of valid states.
:param state: The state to be used to filter (should be a string among
those defined in aiida.common.datastructures.calc_states)
:type state: str
:param computer: a Django DbComputer entry, or a Computer object, of a
computer in the DbComputer table.
A string for the hostname is also valid.
:param user: a Django entry (or its pk) of a user in the DbUser table;
if present, the results are restricted to calculations of that
specific user
:param bool only_computer_user_pairs: if False (default) return a queryset
where each element is a suitable instance of Node (it should
be an instance of Calculation, if everything goes right!)
If True, return only a list of tuples, where each tuple is
in the format
('dbcomputer__id', 'user__id')
[where the IDs are the IDs of the respective tables]
:return: a list of calculation objects matching the filters.
"""
# I assume that calc_states are strings. If this changes in the future,
# update the filter below from dbattributes__tval to the correct field.
from aiida.orm import Computer
from aiida.common.exceptions import InputValidationError
from aiida.orm.implementation.django.calculation.job import JobCalculation
from aiida.common.datastructures import calc_states
from aiida.backends.djsite.db.models import DbUser
if state not in calc_states:
raise InputValidationError(
"querying for calculation state='{}', but it "
"is not a valid calculation state".format(state))
kwargs = {}
if computer is not None:
# I convert it from various type of inputs
# (string, DbComputer, Computer)
# to a DbComputer type
kwargs['dbcomputer'] = Computer.get(computer).dbcomputer
if user is not None:
kwargs['user'] = user
if only_enabled:
kwargs['dbcomputer__enabled'] = True
queryresults = JobCalculation.query(dbattributes__key='state',
dbattributes__tval=state,
**kwargs)
if only_computer_user_pairs:
computer_users_ids = queryresults.values_list(
'dbcomputer__id', 'user__id').distinct()
computer_users = []
for computer_id, user_id in computer_users_ids: # return cls(dbcomputer=DbComputer.get_dbcomputer(computer))DbNode.objects.get(pk=pk).get_aiida_class()
computer_users.append(
(Computer.get(computer_id),
DbUser.objects.get(pk=user_id).get_aiida_class()))
return computer_users
elif limit is not None:
return queryresults[:limit]
else:
return queryresults
'lorbit': 11,
'magmom': 3 * nions * [0.],
'lsorbit': True,
'nbands': nbands,
'sigma': 0.05,
'system': os.path.basename(cifname),
'npar': 8,
}))
tvc.use_structure(structure)
for kind in structure.get_kind_names():
tvc.use_paw(Paw.load_paw(family='LDA', symbol=kind)[0], kind=kind)
tvc.use_kpoints(kp)
tvc.set_computer(Computer.get('monch'))
tvc.set_queue_name('dphys_compute')
tvc.set_resources({'num_machines': nbands / 8, 'num_mpiprocs_per_machine': 8})
tvc.set_max_memory_kb(16000000)
tvc.set_parser_name('vasp.vasp5')
tag = sys.argv[2]
q = QueryTool()
q.set_class(Tvc)
q.add_extra_filter('tag', '=', tag)
ql = map(lambda c: c.get_extra('test-nr'), q.run_query())
last_tn = max(ql)
tvc.store_all()
