def sub_create_bands_data(cls, user=None):
from aiida.orm.data.array.kpoints import KpointsData
from aiida.orm import JobCalculation
from aiida.orm.data.structure import StructureData
from aiida.common.links import LinkType
from aiida.orm.data.array.bands import BandsData
import numpy
s = StructureData(cell=((2., 0., 0.), (0., 2., 0.), (0., 0., 2.)))
s.append_atom(position=(0., 0., 0.),
symbols=['Ba', 'Ti'],
weights=(1., 0.),
name='mytype')
if user is not None:
s.dbnode.user = user._dbuser
s.store()
c = JobCalculation(computer=cls.computer,
resources={
'num_machines': 1,
'num_mpiprocs_per_machine': 1
})
if user is not None:
c.dbnode.user = user._dbuser
c.store()
c.add_link_from(s, "S1", LinkType.INPUT)
c._set_state(calc_states.RETRIEVING)
# define a cell
alat = 4.
cell = numpy.array([
[alat, 0., 0.],
[0., alat, 0.],
[0., 0., alat],
])
k = KpointsData()
k.set_cell(cell)
k.set_kpoints_path()
if user is not None:
k.dbnode.user = user._dbuser
k.store()
b = BandsData()
b.set_kpointsdata(k)
input_bands = numpy.array(
[numpy.ones(4) * i for i in range(k.get_kpoints().shape[0])])
b.set_bands(input_bands, units='eV')
if user is not None:
b.dbnode.user = user._dbuser
b.store()
b.add_link_from(c, link_type=LinkType.CREATE)
return b
def setUpClass(cls, *args, **kwargs):
"""
Create some calculations with various states
"""
super(TestVerdiCalculationCommands, cls).setUpClass()
from aiida.orm import JobCalculation
# Create some calculation
calc1 = JobCalculation(computer=cls.computer,
resources={
'num_machines': 1,
'num_mpiprocs_per_machine': 1
}).store()
calc1._set_state(calc_states.TOSUBMIT)
calc2 = JobCalculation(computer=cls.computer.name,
resources={
'num_machines': 1,
'num_mpiprocs_per_machine': 1
}).store()
calc2._set_state(calc_states.COMPUTED)
calc3 = JobCalculation(computer=cls.computer.id,
resources={
'num_machines': 1,
'num_mpiprocs_per_machine': 1
}).store()
calc3._set_state(calc_states.FINISHED)
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'])
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]
