def test_session_update_and_expiration_1(self):
"""
expire_on_commit=True & adding manually and committing
computer and code objects.
"""
from aiida.orm.computer import Computer
from aiida.orm.code import Code
from aiida.orm.user import User
self.set_connection(expire_on_commit=True)
session = aiida.backends.sqlalchemy.get_scoped_session()
user = User(email=get_configured_user_email())
session.add(user._dbuser)
session.commit()
defaults = dict(name='localhost',
hostname='localhost',
transport_type='local',
scheduler_type='pbspro',
workdir='/tmp/aiida')
computer = Computer(**defaults)
session.add(computer._dbcomputer)
session.commit()
code = Code()
code.set_remote_computer_exec((computer, '/x.x'))
session.add(code.dbnode)
session.commit()
self.drop_connection()
def run_cp2k_charge_density(self):
"""
Compute the charge-density of a structure that can be later used for extracting ddec point charges.
"""
options = {
"resources": {
"num_machines": 4,
"num_mpiprocs_per_machine": 12,
},
"max_wallclock_seconds": 3 * 60 * 60,
}
inputs = {
'code' : Code.get_from_string(self.inputs.cp2k_codename.value),
'structure' : from_cif_to_structuredata(self.ctx.processed_structure),
'parameters' : self.inputs.cp2k_parameters,
'_options' : options,
'_label' : "run_chargedensity_cp2k",
}
# Create the calculation process and launch it
process = Cp2kCalculation.process()
future = submit(process, **inputs)
self.report("pk: {} | Running cp2k to compute the charge-density")
self.ctx.cp2k_pid=future.pid
return ToContext(cp2k=Outputs(future))
def generate_scf_input_params(structure, codename, pseudo_family):
# The inputs
inputs = PwCalculation.process().get_inputs_template()
# The structure
inputs.structure = structure
inputs.code = Code.get_from_string(codename.value)
inputs._options.resources = {"num_machines": 1}
inputs._options.max_wallclock_seconds = 30 * 60
# Kpoints
KpointsData = DataFactory("array.kpoints")
kpoints = KpointsData()
kpoints_mesh = 2
kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh])
inputs.kpoints = kpoints
# Calculation parameters
parameters_dict = {
"CONTROL": {"calculation": "scf",
"tstress": True, # Important that this stays to get stress
"tprnfor": True,},
"SYSTEM": {"ecutwfc": 30.,
"ecutrho": 200.,},
"ELECTRONS": {"conv_thr": 1.e-6,}
}
ParameterData = DataFactory("parameter")
inputs.parameters = ParameterData(dict=parameters_dict)
# Pseudopotentials
inputs.pseudo = get_pseudos(structure, str(pseudo_family))
return inputs
def run(structure_pk, code, atomic_files, group, partition, ranks_per_node, ranks_kp, ranks_diag, kmesh):
# load code from label@computer
c = Code.get_from_string(code)
if not atomic_files:
if c.get_input_plugin_name() == 'quantumespresso.pw':
atomic_files = 'SSSP_acc_PBE'
if c.get_input_plugin_name() == 'exciting.exciting':
atomic_files = 'high_quality_lapw_species'
# create k-point mesh
k = List()
k.extend(kmesh)
for spk in structure_pk:
# load structure from PK
structure = load_node(spk)
# create stress tensor workflow
stress_tensor = Stress_Tensor()
stress_tensor.run(structure=structure,
code=c,
atomic_files=Str(atomic_files),
group=Str(group),
kmesh=k,
partition=Str(partition),
ranks_per_node=Int(ranks_per_node),
ranks_kp=Int(ranks_kp),
ranks_diag=Int(ranks_diag))
def run(structure_pk, code, atomic_files, group, partition, ranks_per_node,
ranks_kp, ranks_diag, kmesh):
# load code from label@computer
c = Code.get_from_string(code)
if not atomic_files:
if c.get_input_plugin_name() == 'quantumespresso.pw':
atomic_files = 'SSSP_acc_PBE'
if c.get_input_plugin_name() == 'exciting.exciting':
atomic_files = 'high_quality_lapw_species'
# create k-point mesh
k = List()
k.extend(kmesh)
for spk in structure_pk:
# load structure from PK
structure = load_node(spk)
# create stress tensor workflow
stress_tensor = Stress_Tensor()
stress_tensor.run(structure=structure,
code=c,
atomic_files=Str(atomic_files),
group=Str(group),
kmesh=k,
partition=Str(partition),
ranks_per_node=Int(ranks_per_node),
ranks_kp=Int(ranks_kp),
ranks_diag=Int(ranks_diag))
def run_block_zeopp(self):
"""
This is the main function that will perform a raspa
calculation for the current pressure
"""
NetworkParameters = DataFactory('zeopp.parameters')
# Create the input dictionary
sigma = self.inputs.probe_molecule.get_dict()['sigma']
params = {
'ha':True,
'block': [sigma, 200],
}
inputs = {
'code' : Code.get_from_string(self.inputs.zeopp_codename.value),
'structure' : self.ctx.processed_structure,
'parameters' : NetworkParameters(dict=params),
'_options' : self.inputs._options,
'_label' : "run_block_zeopp",
}
# Create the calculation process and launch it
process = ZeoppCalculation.process()
future = submit(process, **inputs)
self.report("pk: {} | Running zeo++ block volume calculation".format(future.pid))
self.ctx.block_pk = future.pid
return ToContext(zeopp=Outputs(future))
def run_loading_raspa(self):
"""
This is the main function that will perform a raspa
calculation for the current pressure
"""
pressure = self.ctx.pressures[self.ctx.p]
self.ctx.raspa_parameters['GeneralSettings']['ExternalPressure'] = pressure
if self.ctx.prev_pk is not None:
self.ctx.raspa_parameters['GeneralSettings']['RestartFile'] = True
self.ctx.raspa_parameters['GeneralSettings']['RestartFilePk'] = self.ctx.prev_pk
# Create the input dictionary
inputs = {
'code' : Code.get_from_string(self.inputs.raspa_codename.value),
'structure' : self.ctx.processed_structure,
'parameters' : ParameterData(dict=self.ctx.raspa_parameters),
'_options' : self.inputs._options,
'_label' : "run_loading_raspa",
}
# Create the calculation process and launch it
process = RaspaCalculation.process()
future = submit(process, **inputs)
self.report("pk: {} | Running raspa for the pressure {} [bar]".format(future.pid, pressure/1e5))
self.ctx.p += 1
self.ctx.prev_pk = future.pid
return ToContext(raspa=Outputs(future))
def run_henry_raspa(self):
"""
This is the main function that will perform a raspa
calculation for the current pressure
"""
raspa_parameters = self.inputs.raspa_parameters.get_dict()
raspa_parameters['GeneralSettings'].pop('ExternalPressure')
for i, comp in enumerate(raspa_parameters['Component']):
name = comp['MoleculeName']
raspa_parameters['Component'][0] = {
"MoleculeName" : name,
"MoleculeDefinition" : "TraPPE",
"WidomProbability" : 1.0,
"CreateNumberOfMolecules" : 0,
}
# Create the input dictionary
inputs = {
'code' : Code.get_from_string(self.inputs.raspa_codename.value),
'structure' : self.ctx.processed_structure,
'parameters' : ParameterData(dict=raspa_parameters),
'_options' : self.inputs._options,
'_label' : "run_henry_raspa",
}
# Create the calculation process and launch it
process = RaspaCalculation.process()
future = submit(process, **inputs)
self.report("pk: {} | Running raspa for the Henry coefficients".format(future.pid))
return
def main():
DifferenceCalculation = CalculationFactory('wait.wait')
builder = DifferenceCalculation.get_builder()
builder.code = Code.get_from_string('wait')
builder.options = {'resources': {'num_machines': 1}, 'withmpi': False}
node = submit(builder)
print(node.pk)
def setUpClass(cls):
super(QETestCase, cls).setUpClass()
cls.calc_params = {
'computer': cls.computer,
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 1
}
}
cls.code = Code(remote_computer_exec=(cls.computer, '/x.x')).store()
def generate_scf_input_params(structure, codename, pseudo, element):
# The inputs
inputs = PwCalculation.process().get_inputs_template()
# The structure
inputs.structure = structure
inputs.code = Code.get_from_string(codename)
# calc.label = "PW test"
# calc.description = "My first AiiDA calculation of Silicon with Quantum ESPRESSO"
inputs._options.resources = {"num_machines": 1}
inputs._options.max_wallclock_seconds = 23*30*60
queue="compute"
if queue is not None:
inputs._options.queue_name=queue
# Kpoints
KpointsData = DataFactory("array.kpoints")
kpoints = KpointsData()
# kpoints_mesh = 2
kp=[0,0,0]
f=open('/home/bosonie/AIMS/LDARESULTS/NonRelBirchLDAref', 'r')
for line in f:
a=line.split()
if a[0]==element:
kp[0]=int(a[1])
kp[1]=int(a[3])
kp[2]=int(a[5])
vol=a[7]
kpoints.set_kpoints_mesh([1,1,1])#[kp[0], kp[1], kp[2]])
inputs.kpoints = kpoints
# Calculation parameters
parameters_dict = {
"CONTROL": {"calculation": "scf",
"tstress": True, # Important that this stays to get stress
"tprnfor": True,
"disk_io": "none"},
"SYSTEM": {"ecutwfc": 100.,
"ecutrho": 200.,
"smearing": "gauss",
"degauss": 0.000734986},
"ELECTRONS": {"conv_thr": 1.e-6}
}
ParameterData = DataFactory("parameter")
inputs.parameters = ParameterData(dict=parameters_dict)
pseudos = {}
pseudos[element] = pseudo
inputs.pseudo = pseudos
return inputs
def test_session_update_and_expiration_4(self):
"""
expire_on_commit=False & committing computer and code objects with
their built-in store function.
"""
self.set_connection(expire_on_commit=False)
from aiida.orm.computer import Computer
from aiida.orm.code import Code
from aiida.orm.user import User
session = aiida.backends.sqlalchemy.get_scoped_session()
user = User(email=get_configured_user_email())
session.add(user._dbuser)
session.commit()
defaults = dict(name='localhost',
hostname='localhost',
transport_type='local',
scheduler_type='pbspro',
workdir='/tmp/aiida')
computer = Computer(**defaults)
computer.store()
code = Code()
code.set_remote_computer_exec((computer, '/x.x'))
code.store()
self.drop_connection()
def run_si_scf(codename, pseudo_family):
JobCalc = PwCalculation.process()
inputs = JobCalc.get_inputs_template()
inputs.code = Code.get_from_string(codename)
# calc.label = "PW test"
# calc.description = "My first AiiDA calculation of Silicon with Quantum ESPRESSO"
inputs._options.resources = {"num_machines": 1}
inputs._options.max_wallclock_seconds = 30 * 60
# The structure
alat = 5.4
the_cell = [[alat / 2., alat / 2., 0], [alat / 2., 0, alat / 2.],
[0, alat / 2., alat / 2.]]
StructureData = DataFactory("structure")
structure = StructureData(cell=the_cell)
structure.append_atom(position=(0., 0., 0.), symbols="Si")
structure.append_atom(position=(alat / 4., alat / 4., alat / 4.),
symbols="Si")
inputs.structure = structure
# Kpoints
KpointsData = DataFactory("array.kpoints")
kpoints = KpointsData()
kpoints_mesh = 2
kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh])
inputs.kpoints = kpoints
# Calculation parameters
parameters_dict = {
"CONTROL": {
"calculation": "scf",
"tstress": True,
"tprnfor": True,
},
"SYSTEM": {
"ecutwfc": 30.,
"ecutrho": 200.,
},
"ELECTRONS": {
"conv_thr": 1.e-6,
}
}
ParameterData = DataFactory("parameter")
inputs.parameters = ParameterData(dict=parameters_dict)
# Pseudopotentials
inputs.pseudo = get_pseudos(structure, pseudo_family)
# calc.set_extra("element", "Si")
# calc.submit()
asyncd(JobCalc, **inputs)
def generate_pw_input_params(structure, codename, pseudo_family,parameters, calculation_set, kpoints,gamma,settings,parent_folder):
"""Generate PW input._* from given params """
inputs = {}
inputs['structure'] = structure
inputs['code'] = Code.get_from_string(codename.value)
calculation_set = calculation_set.get_dict()
inputs['options'] = ParameterData(dict=calculation_set)
if parent_folder:
inputs['parent_folder'] = parent_folder
inputs['kpoints']=kpoints
inputs['parameters'] = parameters
inputs['pseudo_family'] = pseudo_family
inputs['settings'] = settings
return inputs
def setUpClass(cls):
super(LocalTestCase, cls).setUpClass()
# Change transport type to local.
cls.computer.set_transport_type('local')
# Configure authinfo for cls.computer and cls.user.
authinfo = DbAuthInfo(dbcomputer=cls.computer.dbcomputer,
aiidauser=cls.user)
authinfo.set_auth_params({})
authinfo.save()
# Set up a code linked to cls.computer. The path is just a fake string.
cls.code = Code(remote_computer_exec=(cls.computer, '/x.x')).store()
def generate_ApeCalculation(codename, element, s, p, d, f):
inp = ApeCalculation.process().get_inputs_template()
inp.code = Code.get_from_string(codename)
inp._options.computer = Computer.get('localhost')
inp._options.resources = {"num_machines": 1}
check = False
for ele in ELEMENTS:
if element == ele.symbol:
nc = int(ele.number)
check = True
print check, nc
if not check:
sys.exit("element is not valid")
corpar = 1
if nc <= 2:
corpar = 0
parameters = ParameterData(
dict={
'Title': '{}'.format(element),
'CalculationMode': 'ae + pp',
'Verbose': '40',
'WaveEquation': 'schrodinger',
'XCFunctional': 'lda_x + lda_c_pz',
'NuclearCharge': '{}'.format(nc),
'PPCalculationTolerance': '1.e-6',
'PPOutputFileFormat': 'upf + siesta',
'CoreCorrection': '{}'.format(corpar),
'EigenSolverTolerance': '1.e-8',
'ODEIntTolerance': '1.e-12'
})
orbitals, PPComponents = get_orb_and_PPcomp(nc, s, p, d, f)
inp.parameters = parameters
inp.orbitals = orbitals
inp.PPComponents = PPComponents
inp._label = "{0} {1} {2} {3}".format(s, p, d, f)
inp._description = "{} pseudo generation with cut of radii in label".format(
element)
return inp
def generate_scf_input_params(structure, codename, pseudo_family):
# The inputs
inputs = PwCalculation.get_builder()
# The structure
inputs.structure = structure
inputs.code = Code.get_from_string(codename)
# calc.label = "PW test"
# calc.description = "My first AiiDA calculation of Silicon with Quantum ESPRESSO"
inputs.options.resources = {"num_machines": 1}
inputs.options.max_wallclock_seconds = 30 * 60
# Kpoints
KpointsData = DataFactory("array.kpoints")
kpoints = KpointsData()
kpoints_mesh = 2
kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh])
inputs.kpoints = kpoints
# Calculation parameters
parameters_dict = {
"CONTROL": {
"calculation": "scf",
"tstress": True, # Important that this stays to get stress
"tprnfor": True,
},
"SYSTEM": {
"ecutwfc": 30.,
"ecutrho": 200.,
},
"ELECTRONS": {
"conv_thr": 1.e-6,
}
}
ParameterData = DataFactory("parameter")
inputs.parameters = ParameterData(dict=parameters_dict)
# Pseudopotentials
inputs.pseudo = validate_and_prepare_pseudos_inputs(
structure, pseudo_family=pseudo_family)
return inputs
def code_rename(self, *args):
import argparse
from aiida.common.exceptions import NotExistent
from aiida.orm.code import Code
parser = argparse.ArgumentParser(
prog=self.get_full_command_name(),
description='Rename a code (change its label).')
# The default states are those that are shown if no option is given
parser.add_argument('old_name', help="The old name of the code")
parser.add_argument('new_name', help="The new name of the code")
parsed_args = parser.parse_args(args)
new_name = parsed_args.new_name
old_name = parsed_args.old_name
try:
code = Code.get_from_string(old_name)
except NotExistent:
print "ERROR! A code with name {} could not be found".format(
old_name)
sys.exit(1)
suffix = '@{}'.format(code.get_computer().name)
if new_name.endswith(suffix):
new_name = new_name[:-len(suffix)]
if '@' in new_name:
print >> sys.stderr, "ERROR! Do not put '@' symbols in the code name"
sys.exit(1)
retrieved_old_name = '{}@{}'.format(code.label,
code.get_computer().name)
# CHANGE HERE
code.label = new_name
retrieved_new_name = '{}@{}'.format(code.label,
code.get_computer().name)
print "Renamed code with ID={} from '{}' to '{}'".format(
code.pk, retrieved_old_name, retrieved_new_name)
def run_ddec_point_charges(self):
"""
Compute ddec point charges from precomputed charge-density.
"""
cp2k_calc = load_node(self.ctx.cp2k_pid)
options = self.inputs._options
#options['prepend_text'] = "export OMP_NUM_THREADS=12"
inputs = {
'code' : Code.get_from_string(self.inputs.ddec_codename.value),
'parameters' : self.inputs.ddec_parameters,
'electronic_calc_folder' : cp2k_calc.out.remote_folder,
'_options' : options,
'_label' : "run_pointcharges_ddec",
}
# Create the calculation process and launch it
process = DdecCalculation.process()
future = submit(process, **inputs)
self.report("pk: {} | Running ddec to compute point charges based on the charge-density")
self.ctx.ddec_pid=future.pid
return ToContext(ddec=Outputs(future))
def inner(builder, code_string):
from aiida.orm.code import Code
builder.code = Code.get_from_string(code_string)
#!/usr/bin/env python
from aiida import load_dbenv
from aiida.orm.code import Code
from aiida.orm import CalculationFactory
# Load the database environment.
load_dbenv()
# Load the PwimmigrantCalculation class.
PwimmigrantCalculation = CalculationFactory('quantumespresso.pwimmigrant')
# Load the Code node representative of the one used to perform the calculations.
code = Code.get('pw_on_TheHive')
# Get the Computer node representative of the one the calculations were run on.
computer = code.get_remote_computer()
# Define the computation resources used for the calculations.
resources = {'num_machines': 1, 'num_mpiprocs_per_machine': 1}
# Initialize the pw_job1 calculation node.
calc1 = PwimmigrantCalculation(computer=computer,
resources=resources,
remote_workdir='/scratch/',
input_file_name='pw_job1.in',
output_file_name='pw_job1.out')
# Initialize the pw_job2 calculation node.
calc2 = PwimmigrantCalculation(computer=computer,
resources=resources,
remote_workdir='/scratch/',
def generate_yambo_input_params(precodename, yambocodename, parent_folder,
parameters, calculation_set, settings):
inputs = YamboCalculation.process().get_inputs_template()
inputs.preprocessing_code = Code.get_from_string(precodename.value)
inputs.code = Code.get_from_string(yambocodename.value)
calculation_set = calculation_set.get_dict()
resource = calculation_set.pop('resources', {})
if resource:
inputs._options.resources = resource
inputs._options.max_wallclock_seconds = calculation_set.pop(
'max_wallclock_seconds', 86400)
max_memory_kb = calculation_set.pop('max_memory_kb', None)
if max_memory_kb:
inputs._options.max_memory_kb = max_memory_kb
queue_name = calculation_set.pop('queue_name', None)
if queue_name:
inputs._options.queue_name = queue_name
custom_scheduler_commands = calculation_set.pop(
'custom_scheduler_commands', None)
if custom_scheduler_commands:
inputs._options.custom_scheduler_commands = custom_scheduler_commands
environment_variables = calculation_set.pop("environment_variables", None)
if environment_variables:
inputs._options.environment_variables = environment_variables
label = calculation_set.pop('label', None)
if label:
inputs._label = label
inputs.parent_folder = parent_folder
inputs.settings = settings
# Get defaults:
edit_parameters = parameters.get_dict()
try:
calc = parent_folder.get_inputs_dict(link_type=LinkType.CREATE)['remote_folder'].inp.parent_calc_folder.get_inputs_dict()\
['remote_folder'].inp.parent_calc_folder.get_inputs_dict()['remote_folder']
except AttributeError:
calc = None
is_pw = False
if isinstance(calc, PwCalculation):
is_pw = True
nelec = calc.out.output_parameters.get_dict()['number_of_electrons']
nocc = None
if calc.out.output_parameters.get_dict()['lsda']== True or\
calc.out.output_parameters.get_dict()['non_colinear_calculation'] == True:
nocc = nelec / 2
else:
nocc = nelec / 2
bndsrnxp = gbndrnge = nocc
ngsblxpp = int(calc.out.output_parameters.get_dict()['wfc_cutoff'] *
0.073498645 / 4 * 0.25) # ev to ry then 1/4
#ngsblxpp = 2
nkpts = calc.out.output_parameters.get_dict()['number_of_k_points']
if not resource:
resource = {
"num_mpiprocs_per_machine": 8,
"num_machines": 1
} # safe trivial defaults
tot_mpi = resource[u'num_mpiprocs_per_machine'] * resource[
u'num_machines']
if 'FFTGvecs' not in edit_parameters.keys():
edit_parameters['FFTGvecs'] = 2
edit_parameters['FFTGvecs_units'] = 'Ry'
if 'BndsRnXp' not in edit_parameters.keys():
edit_parameters['BndsRnXp'] = (bndsrnxp / 2, bndsrnxp / 2 + 1)
if 'GbndRnge' not in edit_parameters.keys():
edit_parameters['GbndRnge'] = (1.0, gbndrnge / 2)
if 'NGsBlkXp' not in edit_parameters.keys():
edit_parameters['NGsBlkXp'] = ngsblxpp
edit_parameters['NGsBlkXp_units'] = 'RL'
if 'QPkrange' not in edit_parameters.keys():
edit_parameters['QPkrange'] = [(1, 1, int(nocc), int(nocc) + 1)
] # To revisit
if 'SE_CPU' not in edit_parameters.keys():
b, qp = split_incom(tot_mpi)
edit_parameters['SE_CPU'] = "1 {qp} {b}".format(qp=qp, b=b)
edit_parameters['SE_ROLEs'] = "q qp b"
if 'X_all_q_CPU' not in edit_parameters.keys():
c, v = split_incom(tot_mpi)
edit_parameters['X_all_q_CPU'] = "1 1 {c} {v}".format(c=c, v=v)
edit_parameters['X_all_q_ROLEs'] = "q k c v"
inputs.parameters = ParameterData(dict=edit_parameters)
return inputs
def test_code_local(self):
import tempfile
from aiida.orm.code 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() as f:
f.write("#/bin/bash\n\necho test run\n")
f.flush()
code.add_path(f.name, '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')
def test_remote(self):
import tempfile
from aiida.orm.code import Code
from aiida.orm.computer import Computer
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() as f:
f.write("#/bin/bash\n\necho test run\n")
f.flush()
code.add_path(f.name, 'test.sh')
with self.assertRaises(ValidationError):
# There are files inside
code.store()
# If there are no files, I can store
code.remove_path('test.sh')
code.store()
self.assertEquals(code.get_remote_computer().pk, self.computer.pk)
self.assertEquals(code.get_remote_exec_path(), '/bin/ls')
self.assertEquals(code.get_execname(), '/bin/ls')
self.assertTrue(code.can_run_on(self.computer.dbcomputer))
self.assertTrue(code.can_run_on(self.computer))
othercomputer = Computer(name='another_localhost',
hostname='localhost',
transport_type='local',
scheduler_type='pbspro',
workdir='/tmp/aiida').store()
self.assertFalse(code.can_run_on(othercomputer))
def setUp(self):
"""
"""
from aiida import work
from aiida.orm.code import Code
from aiida.orm.nodes.parameter import Dict
from aiida.orm.nodes.structure import StructureData
from aiida.orm.nodes.remote import RemoteData
from ase.spacegroup import crystal
from aiida_quantumespresso.calculations.pw import PwCalculation
from aiida_yambo.calculations.gw import YamboCalculation
from aiida.common.links import LinkType
from aiida.orm.computer import Computer as AiidaOrmComputer
from aiida.common.datastructures import calc_states
from aiida.plugins.utils import DataFactory
runner = work.Runner(poll_interval=0.,
rmq_config=None,
enable_persistence=None)
work.set_runner(runner)
self.computer = AiidaOrmComputer(name="testcase")
# conf_attrs hostname, description, enabled_state, transport_type, scheduler_type, workdir
# mpirun_command , default_mpiprocs_per_machine,
self.computer._set_hostname_string("localhost")
self.computer._set_enabled_state_string('True')
self.computer._set_transport_type_string("local")
self.computer._set_scheduler_type_string("direct")
self.computer._set_workdir_string("/tmp/testcase/{username}/base")
self.computer.store()
create_authinfo(computer=self.computer).store()
self.code_yambo = Code()
self.code_yambo.label = "yambo"
os_env = os.environ.copy()
yambo_path = subprocess.check_output(['which', 'mock_yambo'],
env=os_env).strip()
self.code_yambo.set_remote_computer_exec((self.computer, yambo_path))
self.code_yambo.set_input_plugin_name('yambo.yambo')
self.code_p2y = Code()
self.code_p2y.label = "p2y"
p2y_path = subprocess.check_output(['which', 'mock_p2y'],
env=os_env).strip()
self.code_p2y.set_remote_computer_exec((self.computer, p2y_path))
self.code_p2y.set_input_plugin_name('yambo.yambo')
self.code_yambo.store()
self.code_p2y.store()
self.calc_pw = PwCalculation()
self.calc_pw.set_computer(self.computer)
self.calc_pw.set_resources({
"num_machines": 1,
"num_mpiprocs_per_machine": 16,
'default_mpiprocs_per_machine': 16
})
StructureData = DataFactory('structure')
cell = [[15.8753100000, 0.0000000000, 0.0000000000],
[0.0000000000, 15.8753100000, 0.0000000000],
[0.0000000000, 0.0000000000, 2.4696584760]]
s = StructureData(cell=cell)
self.calc_pw.use_structure(s)
print((self.calc_pw.store_all(), " pw calc"))
pw_remote_folder = RemoteData(computer=self.computer,
remote_path="/tmp/testcase/work/calcPW")
print((pw_remote_folder.store(), "pw remote data"))
self.calc_pw._set_state(calc_states.PARSING)
pw_remote_folder.add_link_from(self.calc_pw,
label='remote_folder',
link_type=LinkType.CREATE)
outputs = Dict(
dict={
"lsda": False,
"number_of_bands": 80,
"number_of_electrons": 8.0,
"number_of_k_points": 147,
"non_colinear_calculation": False
})
outputs.store()
outputs.add_link_from(self.calc_pw,
label='output_parameters',
link_type=LinkType.CREATE)
self.calc = YamboCalculation()
self.calc.set_computer(self.computer)
self.calc.use_code(self.code_p2y)
p2y_settings = {
u'ADDITIONAL_RETRIEVE_LIST':
[u'r-*', u'o-*', u'l-*', u'l_*', u'LOG/l-*_CPU_1'],
u'INITIALISE':
True
}
yambo_settings = {
u'ADDITIONAL_RETRIEVE_LIST':
[u'r-*', u'o-*', u'l-*', u'l_*', u'LOG/l-*_CPU_1']
}
self.calc.use_settings(Dict(dict=p2y_settings))
self.calc.set_resources({
"num_machines": 1,
"num_mpiprocs_per_machine": 16,
'default_mpiprocs_per_machine': 16
})
self.calc.use_parent_calculation(self.calc_pw)
print((self.calc.store_all(), " yambo calc"))
self.calc._set_state(calc_states.PARSING)
a = 5.388
cell = crystal('Si', [(0, 0, 0)],
spacegroup=227,
cellpar=[a, a, a, 90, 90, 90],
primitive_cell=True)
self.struc = StructureData(ase=cell)
self.struc.store()
self.parameters = Dict(
dict={
"BndsRnXp": [1.0, 48.0],
"Chimod": "Hartree",
"DysSolver": "n",
"FFTGvecs": 25,
"FFTGvecs_units": "Ry",
"GbndRnge": [1.0, 48.0],
"HF_and_locXC": True,
"LongDrXp": [1.0, 0.0, 0.0],
"NGsBlkXp": 2,
"NGsBlkXp_units": "Ry",
"QPkrange": [[1, 145, 3, 5]],
"SE_CPU": "1 2 4",
"SE_ROLEs": "q qp b",
"X_all_q_CPU": "1 1 4 2",
"X_all_q_ROLEs": "q k c v",
"em1d": True,
"gw0": True,
"ppa": True,
"rim_cut": True
})
self.yambo_settings = Dict(
dict={
"ADDITIONAL_RETRIEVE_LIST": [
"r-*", "o-*", "l-*", "l_*", "LOG/l-*_CPU_1",
"aiida/ndb.QP", "aiida/ndb.HF_and_locXC"
]
})
self.p2y_settings = Dict(
dict={
"ADDITIONAL_RETRIEVE_LIST": [
'r-*', 'o-*', 'l-*', 'l_*', 'LOG/l-*_CPU_1',
'aiida/ndb.QP', 'aiida/ndb.HF_and_locXC'
],
'INITIALISE':
True
})
self.yambo_calc_set = Dict(
dict={
'resources': {
"num_machines": 1,
"num_mpiprocs_per_machine": 16
},
'max_wallclock_seconds': 60 * 29,
'max_memory_kb': 1 * 88 * 1000000,
"queue_name":
"s3parvc3", #'custom_scheduler_commands': u"#PBS -A Pra14_3622" ,
'environment_variables': {
"OMP_NUM_THREADS": "1"
}
})
self.p2y_calc_set = Dict(
dict={
'resources': {
"num_machines": 1,
"num_mpiprocs_per_machine": 2
},
'max_wallclock_seconds': 60 * 2,
'max_memory_kb': 1 * 10 * 1000000,
"queue_name":
"s3parvc3", # 'custom_scheduler_commands': u"#PBS -A Pra14_3622" ,
'environment_variables': {
"OMP_NUM_THREADS": "2"
}
})
self.remote_folder = RemoteData(computer=self.computer,
remote_path="/tmp/testcase/work/calcX")
self.remote_folder.store()
self.remote_folder.add_link_from(self.calc,
label='remote_folder',
link_type=LinkType.CREATE)
self.calc._set_state(calc_states.FINISHED)
def siesta_develop():
sd = {}
from aiida.orm.code import Code
sd["code"] = Code.get_from_string('siesta@develop')
return sd
def inner(inputs, code_string):
from aiida.orm.code import Code
inputs.code = Code.get_from_string(code_string)
def get_pw_calculation(wf_params, only_initialization=False, parent_calc=None,
parent_remote_folder=None):
"""
Returns a stored calculation
"""
# default max number of seconds for a calculation with only_initialization=True
# (should be largely sufficient)
default_max_seconds_only_init = 1800
from aiida.orm.code import Code
calculation = wf_params['input']['relaxation_scheme']
if only_initialization:
wf_params['calculation_set'] = update_nested_dict(
wf_params.get('calculation_set',{}),
{'max_wallclock_seconds': default_max_seconds_only_init,
'resources': {'num_machines': 1}})
if parent_calc is None:
code = Code.get_from_string(wf_params["codename"])
calc = code.new_calc()
calc.use_structure(wf_params["structure"])
calc.use_pseudos_from_family(wf_params["pseudo_family"])
if parent_remote_folder is None:
pw_parameters = get_pwparameterdata_from_wfparams(wf_params, calculation=calculation)
else:
# restart from a remote folder (typically, with charge density)
pw_parameters = get_pwparameterdata_from_wfparams(wf_params, restart_mode='restart',
calculation=calculation)
calc._set_parent_remotedata(parent_remote_folder)
else:
if calculation in ['bands']:
calc = parent_calc.create_restart(force_restart=True,use_output_structure=True)
else:
calc = parent_calc.create_restart(force_restart=True)
pw_parameters = get_pwparameterdata_from_wfparams(wf_params,
restart_mode='restart', calculation=calculation)
if 'vdw_table' in wf_params:
calc.use_vdw_table(wf_params['vdw_table'])
calc.use_parameters(pw_parameters)
calc.use_kpoints(wf_params['kpoints'])
calc = set_the_set(calc,wf_params.get('calculation_set',{}))
# set the settings if present
try:
settings_dict = wf_params['settings']
except KeyError:
try:
settings_dict = parent_calc.inp.settings.get_dict()
if calc.inp.parameters.get_dict()['CONTROL']['calculation'] == 'bands':
# for bands calculation we take out the npools specification
# from the parent settings as the number of kpoints will
# be different
cmdline = settings_dict.get('cmdline',[])
the_cmdline = take_out_npools_from_cmdline(cmdline)
if the_cmdline:
settings_dict['cmdline'] = the_cmdline
except AttributeError:
settings_dict = {}
if calc.inp.parameters.get_dict()['CONTROL']['calculation'] == 'bands':
settings_dict['also_bands'] = True
if only_initialization:
settings_dict['ONLY_INITIALIZATION'] = only_initialization
_ = settings_dict.pop('also_bands',None)
if settings_dict:
settings = ParameterData(dict=settings_dict)
calc.use_settings(settings)
calc.store_all()
return calc
def deposit(what,
type,
author_name=None,
author_email=None,
url=None,
title=None,
username=None,
password=False,
user_email=None,
code_label=default_options['code'],
computer_name=None,
replace=None,
message=None,
**kwargs):
"""
Launches a
:py:class:`aiida.orm.implementation.general.calculation.job.AbstractJobCalculation`
to deposit data node to \*COD-type database.
:return: launched :py:class:`aiida.orm.implementation.general.calculation.job.AbstractJobCalculation`
instance.
:raises ValueError: if any of the required parameters are not given.
"""
from aiida.common.setup import get_property
parameters = {}
if not what:
raise ValueError("Node to be deposited is not supplied")
if not type:
raise ValueError("Deposition type is not supplied. Should be "
"one of the following: 'published', "
"'prepublication' or 'personal'")
if not username:
username = get_property('tcod.depositor_username')
if not username:
raise ValueError("Depositor username is not supplied")
if not password:
parameters['password'] = get_property('tcod.depositor_password')
if not parameters['password']:
raise ValueError("Depositor password is not supplied")
if not user_email:
user_email = get_property('tcod.depositor_email')
if not user_email:
raise ValueError("Depositor email is not supplied")
parameters['deposition-type'] = type
parameters['username'] = username
parameters['user_email'] = user_email
if type == 'published':
pass
elif type in ['prepublication', 'personal']:
if not author_name:
author_name = get_property('tcod.depositor_author_name')
if not author_name:
raise ValueError("Author name is not supplied")
if not author_email:
author_email = get_property('tcod.depositor_author_email')
if not author_email:
raise ValueError("Author email is not supplied")
if not title:
raise ValueError("Publication title is not supplied")
else:
raise ValueError("Unknown deposition type '{}' -- should be "
"one of the following: 'published', "
"'prepublication' or 'personal'".format(type))
if replace:
if str(int(replace)) != replace or int(replace) < 10000000 \
or int(replace) > 99999999:
raise ValueError("ID of the replaced structure ({}) does not "
"seem to be valid TCOD ID: must be in "
"range [10000000,99999999]".format(replace))
elif message:
raise ValueError("Message is given while the structure is not "
"redeposited -- log message is relevant to "
"redeposition only")
kwargs['additional_tags'] = {}
if title:
kwargs['additional_tags']['_publ_section_title'] = title
if author_name:
kwargs['additional_tags']['_publ_author_name'] = author_name
if replace:
kwargs['additional_tags']['_tcod_database_code'] = replace
kwargs['datablock_names'] = [replace]
cif = export_cifnode(what, store=True, **kwargs)
from aiida.orm.code import Code
from aiida.orm.computer import Computer
from aiida.orm.data.parameter import ParameterData
from aiida.common.exceptions import NotExistent
code = Code.get_from_string(code_label)
computer = None
if computer_name:
computer = Computer.get(computer_name)
calc = code.new_calc(computer=computer)
calc.set_resources({'num_machines': 1, 'num_mpiprocs_per_machine': 1})
if password:
import getpass
parameters['password'] = getpass.getpass("Password: ")
if author_name:
parameters['author_name'] = author_name
if author_email:
parameters['author_email'] = author_email
if url:
parameters['url'] = url
if replace:
parameters['replace'] = True
if message:
parameters['log-message'] = str(message)
pd = ParameterData(dict=parameters)
calc.use_cif(cif)
calc.use_parameters(pd)
calc.store_all()
calc.submit()
return calc
