def test_all_calculation_inputs(vasp_code, cstdn_code, incar, kpoints, poscar,
with_pbe_potcars, calc_type, temporary_cwd):
from aiida.engine import run
from aiida_cusp.data import VaspPotcarData
from aiida_cusp.calculators import VaspCalculation
from aiida_cusp.utils.defaults import CustodianDefaults
# default custodian settings and handlers
custodian_settings = CustodianDefaults.CUSTODIAN_SETTINGS
custodian_handlers = CustodianDefaults.ERROR_HANDLER_SETTINGS
# define code
vasp_code.set_attribute('input_plugin', 'cusp.vasp')
cstdn_code.set_attribute('input_plugin', 'cusp.vasp')
# define all possible inputs
inputs = {
'code': vasp_code,
'incar': incar,
'kpoints': kpoints,
'potcar': VaspPotcarData.from_structure(poscar, 'pbe'),
'custodian': {
'settings': custodian_settings,
'handlers': custodian_handlers,
},
'metadata': {
'dry_run': True,
'options': {'resources': {'num_machines': 1}},
},
}
if calc_type == 'normal':
inputs['poscar'] = poscar
elif calc_type == 'neb':
neb_path = {'node_00': poscar, 'node_01': poscar, 'node_02': poscar}
inputs['neb_path'] = neb_path
run(VaspCalculation, **inputs)
def example_failure(cp2k_code):
"""Run failing calculation"""
print("Testing CP2K failure...")
# a broken CP2K input
parameters = Dict(dict={'GLOBAL': {'FOO_BAR_QUUX': 42}})
print("Submitted calculation...")
# Construct process builder
builder = Cp2kCalculation.get_builder()
builder.parameters = parameters
builder.code = cp2k_code
builder.metadata.options.resources = {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
}
builder.metadata.options.max_wallclock_seconds = 1 * 2 * 60
try:
run(builder)
print("ERROR!")
print("CP2K failure was not recognized")
sys.exit(3)
except OutputParsingError:
print("CP2K failure correctly recognized")
def main(codelabel):
"""Example usage: verdi run thistest.py cp2k@localhost"""
print("Testing CP2K multistage workchain on H2O")
print(">>> Using 'singlepoint' tag, with no output structure")
code = Code.get_from_string(codelabel)
atoms = ase.build.molecule('H2O')
atoms.center(vacuum=2.0)
structure = StructureData(ase=atoms)
options = {
"resources": {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
},
"max_wallclock_seconds": 1 * 3 * 60,
}
inputs = {
'structure': structure,
'protocol_tag': Str('singlepoint'),
'cp2k_base': {
'cp2k': {
'code': code,
'metadata': {
'options': options,
}
}
}
}
run(Cp2kMultistageWorkChain, **inputs)
def run_multistage_h2o_fail(cp2k_code):
"""Example usage: verdi run thistest.py cp2k@localhost"""
print("Testing CP2K multistage workchain on H2O")
print(">>> Making it fail because of an unphysical Multiplicity")
atoms = ase.build.molecule('H2O')
atoms.center(vacuum=2.0)
structure = StructureData(ase=atoms)
parameters = Dict(
dict={'FORCE_EVAL': {
'DFT': {
'UKS': True,
'MULTIPLICITY': 666,
}
}})
# Construct process builder
builder = Cp2kMultistageWorkChain.get_builder()
builder.structure = structure
builder.protocol_tag = Str('test')
builder.cp2k_base.max_iterations = Int(1)
builder.cp2k_base.cp2k.parameters = parameters
builder.cp2k_base.cp2k.code = cp2k_code
builder.cp2k_base.cp2k.metadata.options.resources = {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
}
builder.cp2k_base.cp2k.metadata.options.max_wallclock_seconds = 1 * 3 * 60
run(builder)
def main(code_string, datafiles, parameters):
"""Main method to setup the calculation."""
# First, we need to fetch the AiiDA datatypes which will
# house the inputs to our calculation
dict_data = DataFactory('dict')
# Then, we set the workchain we would like to call
workchain = WorkflowFactory('logger.gc_example')
# Set inputs for the following WorkChain execution
inputs = AttributeDict()
# inputs.metadata = {'options': {'resources': {'num_machines': 1, 'num_mpiprocs_per_machine': 1},
# 'parser_name': 'logger',
# 'withmpi': False,
# 'output_filename': 'logger.out'}}
# Set code
inputs.code = Code.get_from_string(code_string)
# Set datafiles
inputs.datafiles = datafiles
# Set parameters
inputs.parameters = dict_data(dict=parameters)
# Set workchain related inputs, in this case, give more explicit output to report
inputs.verbose = Bool(True)
# Submit the requested workchain with the supplied inputs
run(workchain, **inputs)
def main(codelabel):
"""Run failing calculation"""
try:
code = Code.get_from_string(codelabel)
except NotExistent:
print("The code '{}' does not exist".format(codelabel))
sys.exit(1)
print("Testing CP2K failure...")
# a broken CP2K input
parameters = Dict(dict={'GLOBAL': {'FOO_BAR_QUUX': 42}})
options = {
"resources": {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
},
"max_wallclock_seconds": 1 * 2 * 60,
}
print("Submitted calculation...")
inputs = {'parameters': parameters, 'code': code, 'metadata': {'options': options,}}
try:
run(Cp2kCalculation, **inputs)
print("ERROR!")
print("CP2K failure was not recognized")
sys.exit(3)
except OutputParsingError:
print("CP2K failure correctly recognized")
sys.exit(0)
def run_multistage_h2o_testfile(cp2k_code):
"""Example usage: verdi run thistest.py cp2k@localhost"""
print("Testing CP2K multistage workchain on H2O")
print(">>> Loading a custom protocol from file testfile.yaml")
atoms = ase.build.molecule('H2O')
atoms.center(vacuum=2.0)
structure = StructureData(ase=atoms)
thisdir = os.path.dirname(os.path.abspath(__file__))
# Construct process builder
builder = Cp2kMultistageWorkChain.get_builder()
builder.structure = structure
builder.protocol_yaml = SinglefileData(file=os.path.abspath(
os.path.join(thisdir, '..', 'data', 'test_multistage_protocol.yaml')))
builder.cp2k_base.cp2k.code = cp2k_code
builder.cp2k_base.cp2k.metadata.options.resources = {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
}
builder.cp2k_base.cp2k.metadata.options.max_wallclock_seconds = 1 * 3 * 60
run(builder)
def example(code, formchk_pk):
builder = CubegenCalculation.get_builder()
builder.parent_calc_folder = load_node(formchk_pk).outputs.remote_folder
builder.code = code
builder.parameters = Dict(
dict={
"h**o": {
"kind": "MO=H**o",
"npts": -2,
},
"density": {
"kind": "Density=SCF",
"npts": -2,
},
})
builder.retrieve_cubes = Bool(True)
builder.metadata.options.resources = {
"tot_num_mpiprocs": 1,
"num_machines": 1,
}
builder.metadata.options.max_wallclock_seconds = 5 * 60
print("Submitted calculation...")
run(builder)
def main(raspa_code_label):
"""Prepare inputs and submit the work chain."""
builder = SimAnnealingWorkChain.get_builder()
builder.metadata.label = "test"
builder.raspa_base.raspa.code = Code.get_from_string(raspa_code_label)
builder.raspa_base.raspa.metadata.options = {
"resources": {
"num_machines": 1,
"tot_num_mpiprocs": 1,
},
"max_wallclock_seconds": 1 * 60 * 60,
}
builder.structure = CifData(file=os.path.abspath('data/HKUST-1.cif'),
label="HKUST-1")
builder.molecule = Str('co2')
builder.parameters = Dict(
dict={
"ff_framework": "UFF", # (str) Forcefield of the structure.
"temperature_list": [
300, 200, 100
], # (list) List of decreasing temperatures for the annealing.
"mc_steps": int(10), # (int) Number of MC cycles.
"number_of_molecules":
3 # (int) Number of molecules loaded in the framework.
})
run(builder)
def test_run_failure(new_workdir):
"""Testing CP2K failure"""
from aiida.engine import run
from aiida.plugins import CalculationFactory
from aiida.orm import Dict
from aiida.common.exceptions import OutputParsingError
computer = get_computer(workdir=new_workdir)
code = get_code(entry_point="cp2k", computer=computer)
# a broken CP2K input
parameters = Dict(dict={"GLOBAL": {"FOO_BAR_QUUX": 42}})
options = {
"resources": {
"num_machines": 1,
"num_mpiprocs_per_machine": 1
},
"max_wallclock_seconds": 1 * 2 * 60,
}
print("Submitted calculation...")
inputs = {
"parameters": parameters,
"code": code,
"metadata": {
"options": options
}
}
with pytest.raises(OutputParsingError):
run(CalculationFactory("cp2k"), **inputs)
def test_kkr_from_kkr(self):
"""
continue KKR calculation after a previous KKR calculation instead of starting from voronoi
"""
from aiida.orm import Code, load_node
from aiida.plugins import DataFactory
from masci_tools.io.kkr_params import kkrparams
from aiida_kkr.calculations.kkr import KkrCalculation
Dict = DataFactory('dict')
# load necessary files from db_dump files
from aiida.tools.importexport import import_data
import_data('files/db_dump_kkrcalc.tar.gz')
kkr_calc = load_node('3058bd6c-de0b-400e-aff5-2331a5f5d566')
# prepare computer and code (needed so that
prepare_code(kkr_codename, codelocation, computername, workdir)
# extract KKR parameter (add missing values)
params_node = kkr_calc.inputs.parameters
# load code from database and create new voronoi calculation
code = Code.get_from_string(kkr_codename+'@'+computername)
options = {'resources': {'num_machines':1, 'tot_num_mpiprocs':1}, 'queue_name': queuename}
builder = KkrCalculation.get_builder()
builder.code = code
builder.metadata.options = options
builder.parameters = params_node
builder.parent_folder = kkr_calc.outputs.remote_folder
builder.metadata.dry_run = True
from aiida.engine import run
run(builder)
def launch():
"""Launch the relax work chain for a basic silicon crystal structure at a range of scaling factors."""
print(f'Running {STRUCTURE} with {CODE}')
pymatgen_structure = Structure.from_file(
f'../../../common/data/{STRUCTURE}.cif')
structure = orm.StructureData(pymatgen=pymatgen_structure)
parameters_dict = {
'structure': structure,
'sub_process_class': 'common_workflows.relax.abinit',
'generator_inputs': {
'protocol': 'precise',
'relax_type': RelaxType.ATOMS,
'threshold_forces': 0.001,
'calc_engines': {
'relax': {
'code': CODE,
'options': {
'withmpi': True,
'max_wallclock_seconds': 24 * 60**2,
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 4
}
}
}
},
**KWARGS
}
}
run(EquationOfStateWorkChain, **parameters_dict)
def example_relax(code, pseudo_family):
"""Run simple silicon DFT calculation."""
print("Testing the AbinitBaseWorkChain relaxation on Silicon")
thisdir = os.path.dirname(os.path.realpath(__file__))
structure = StructureData(pymatgen=mg.Structure.from_file(
os.path.join(thisdir, "files", 'Si.cif')))
pseudo_family = Group.objects.get(label=pseudo_family)
pseudos = pseudo_family.get_pseudos(structure=structure)
base_parameters_dict = {
'kpoints_distance': Float(0.6), # 1 / Angstrom
'abinit': {
'code':
code,
'structure':
structure,
'pseudos':
pseudos,
'parameters':
Dict(
dict={
'optcell':
2, # Cell optimization
'ionmov':
22, # Atoms relaxation
'tolmxf':
5.0e-5, # Tolerence on the maximal force
'ecutsm':
0.5, # Energy cutoff smearing, in Hartree
'ecut':
20.0, # Maximal kinetic energy cut-off, in Hartree
'nshiftk':
4, # of the reciprocal space (that form a BCC lattice !)
'shiftk': [[0.5, 0.5, 0.5], [0.5, 0.0, 0.0],
[0.0, 0.5, 0.0], [0.0, 0.0, 0.5]],
'nstep':
20, # Maximal number of SCF cycles
'toldfe':
1.0e-6, # Will stop when, twice in a row, the difference
# between two consecutive evaluations of total energy
# differ by less than toldfe (in Hartree)
}),
'metadata': {
'options': {
'withmpi': True,
'max_wallclock_seconds': 10 * 60,
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 4,
}
}
}
}
}
print("Running work chain...")
run(AbinitBaseWorkChain, **base_parameters_dict)
def test_save_load(self):
process = DummyProcess()
saved_state = plumpy.Bundle(process)
process.close()
loaded_process = saved_state.unbundle()
run(loaded_process)
self.assertEqual(loaded_process.state, plumpy.ProcessState.FINISHED)
def example_ev(julia_code, submit=True):
"""
Example to prepare and run a Sinlge Component
"""
pwd = os.path.dirname(os.path.realpath(__file__))
framework = CifData(file=os.path.join(pwd, 'files', 'HKUST1.cif')).store()
acc_voronoi_nodes = SinglefileData(
file=os.path.join(pwd, 'files', 'HKUST1.voro_accessible')).store()
data_path = os.path.join(pwd, 'data')
print(data_path)
parameters = Dict(
dict={
'data_path': data_path,
'ff': 'UFF.csv',
'cutoff': 12.5,
'mixing': 'Lorentz-Berthelot',
'framework': framework.filename,
'frameworkname': framework.filename[:-4],
'adsorbate': "Xe",
'temperature': 298.0,
'output_filename': "Ev_" + framework.filename[:-4] + ".csv",
'input_template': 'ev_vdw_kh_1comp_template',
'ev_setting': [99, 95, 90, 80, 50
], # if not defined the default is [90,80,50]
})
builder = PorousMaterialsCalculation.get_builder()
builder.structure = {framework.filename[:-4]: framework}
builder.parameters = parameters
builder.acc_voronoi_nodes = {framework.filename[:-4]: acc_voronoi_nodes}
builder.code = julia_code
builder.metadata.options.resources = { #pylint: disable = no-member
'num_machines': 1,
'num_mpiprocs_per_machine': 1,
}
builder.metadata.options.max_wallclock_seconds = 1 * 30 * 60 #pylint: disable = no-member
builder.metadata.options.withmpi = False #pylint: disable = no-member
if submit:
print('Testing PorousMaterials Ev for single component...')
res, pk = run_get_pk(builder)
print('Voronoi Energy is: ',
res['output_parameters'].dict.HKUST1['Ev_probe']['Ev_minimum'])
print('calculation pk: ', pk)
print('OK, calculation has completed successfully')
pytest.base_calc_pk = pk
else:
print('Generating test input ...')
builder.metadata.dry_run = True #pylint: disable = no-member
builder.metadata.store_provenance = False #pylint: disable = no-member
run(builder)
print('submission test successful')
print("In order to actually submit, add '--submit'")
print('-----------')
def example_dft(code, pseudo_family):
"""Run simple silicon DFT calculation."""
print('Testing Abinit Total energy on Silicon using AbinitCalculation')
thisdir = os.path.dirname(os.path.realpath(__file__))
structure = StructureData(pymatgen=mg.core.Structure.from_file(
os.path.join(thisdir, 'files', 'Si.cif')))
pseudo_family = Group.objects.get(label=pseudo_family)
pseudos = pseudo_family.get_pseudos(structure=structure)
kpoints = KpointsData()
kpoints.set_cell_from_structure(structure)
kpoints.set_kpoints_mesh([2, 2, 2])
# kpoints.set_kpoints_mesh_from_density(2.0)
parameters_dict = {
'code':
code,
'structure':
structure,
'pseudos':
pseudos,
'kpoints':
kpoints,
'parameters':
Dict(
dict={
'ecut':
8.0, # Maximal kinetic energy cut-off, in Hartree
'nshiftk':
4, # of the reciprocal space (that form a BCC lattice !)
'shiftk': [[0.5, 0.5, 0.5], [0.5, 0.0, 0.0], [0.0, 0.5, 0.0],
[0.0, 0.0, 0.5]],
'nstep':
20, # Maximal number of SCF cycles
'toldfe':
1.0e-6, # Will stop when, twice in a row, the difference
# between two consecutive evaluations of total energy
# differ by less than toldfe (in Hartree)
}),
'metadata': {
'options': {
'withmpi': True,
'max_wallclock_seconds': 2 * 60,
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 4,
}
}
}
}
print('Running calculation...')
run(AbinitCalculation, **parameters_dict)
def example_multistage_al(cp2k_code):
"""Example usage: verdi run thistest.py cp2k@localhost"""
print("Testing CP2K multistage workchain on Al (RKS, needs smearing)...")
print(
"EXPECTED: the OT (settings_0) will converge to a negative bandgap, then we switch to SMEARING (settings_1)"
)
thisdir = os.path.dirname(os.path.abspath(__file__))
structure = StructureData(
ase=ase.io.read(os.path.join(thisdir, '../data/Al.cif')))
# testing user change of parameters and protocol
parameters = Dict(
dict={'FORCE_EVAL': {
'DFT': {
'MGRID': {
'CUTOFF': 250,
}
}
}})
protocol_mod = Dict(
dict={
'initial_magnetization': {
'Al': 0
},
'settings_0': {
'FORCE_EVAL': {
'DFT': {
'SCF': {
'OUTER_SCF': {
'MAX_SCF': 5,
}
}
}
}
}
})
# Construct process builder
builder = Cp2kMultistageWorkChain.get_builder()
builder.structure = structure
builder.protocol_tag = Str('test')
builder.starting_settings_idx = Int(0)
builder.protocol_modify = protocol_mod
builder.cp2k_base.cp2k.parameters = parameters
builder.cp2k_base.cp2k.code = cp2k_code
builder.cp2k_base.cp2k.metadata.options.resources = {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
}
builder.cp2k_base.cp2k.metadata.options.max_wallclock_seconds = 1 * 3 * 60
run(builder)
def main(zeopp_code_label, raspa_code_label):
"""
Prepare inputs and submit the Isotherm workchain.
Usage: verdi run run_HTSMultiTWorkChain_HKUST-1_2comp.py zeopp@teslin raspa37@teslin
"""
builder = HTSMultiTempWorkChain.get_builder()
builder.metadata.label = "test"
builder.raspa_base.raspa.code = Code.get_from_string(raspa_code_label)
builder.zeopp.code = Code.get_from_string(zeopp_code_label)
builder.zeopp.atomic_radii = SinglefileData(file=os.path.abspath('../aiida_matdis/data/UFF.rad'))
options = {
"resources": {
"num_machines": 1,
"tot_num_mpiprocs": 1,
},
"max_wallclock_seconds": 1 * 60 * 60,
"withmpi": False,
}
builder.raspa_base.raspa.metadata.options = options
builder.zeopp.metadata.options = options
builder.structure = CifData(file=os.path.abspath('../aiida_matdis/data/HKUST-1.cif'), label="hkust1")
builder.mixture = Dict(dict={
'comp1': {
'name': 'xenon',
'molfraction': 0.20
},
'comp2': {
'name': 'krypton',
'molfraction': 0.80
},
})
builder.parameters = Dict(
dict={
'ff_framework': 'UFF', # Default: UFF
'temperature_list': [273, 298], # (K) Note: higher temperature will have less adsorbate and it is faster
'zeopp_volpo_samples': 100, # Default: 1e5 *NOTE: default is good for standard real-case!
'zeopp_sa_samples': 100, # Default: 1e5 *NOTE: default is good for standard real-case!
'zeopp_block_samples': 100, # Default: 100
'raspa_widom_cycles': 500, # Default: 1e5
'raspa_gcmc_init_cycles': 500, # Default: 1e3
'raspa_gcmc_prod_cycles': 500, # Default: 1e4
'pressure_list': [0.1, 1.0],
'lcd_max': 15.0,
'pld_min': 3.5,
'probe_based': False,
})
run(builder)
def main(codelabel):
"""Example usage: verdi run thistest.py cp2k@localhost"""
print("Testing CP2K multistage workchain on Al (RKS, needs smearing)...")
print("EXPECTED: the OT (settings_0) will converge to a negative bandgap, then we switch to SMEARING (settings_1)")
code = Code.get_from_string(codelabel)
thisdir = os.path.dirname(os.path.abspath(__file__))
structure = StructureData(ase=ase.io.read(os.path.join(thisdir, '../data/Al.cif')))
# testing user change of parameters and protocol
parameters = Dict(dict={'FORCE_EVAL': {'DFT': {'MGRID': {'CUTOFF': 250,}}}})
protocol_mod = Dict(dict={
'initial_magnetization': {
'Al': 0
},
'settings_0': {
'FORCE_EVAL': {
'DFT': {
'SCF': {
'OUTER_SCF': {
'MAX_SCF': 5,
}
}
}
}
}
})
options = {
"resources": {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
},
"max_wallclock_seconds": 1 * 3 * 60,
}
inputs = {
'structure': structure,
'protocol_tag': Str('test'),
'starting_settings_idx': Int(0),
'protocol_modify': protocol_mod,
'cp2k_base': {
'cp2k': {
'parameters': parameters,
'code': code,
'metadata': {
'options': options,
}
}
}
}
run(Cp2kMultistageWorkChain, **inputs)
def test_startpot_Cu_simple(self):
"""
simple Cu noSOC, FP, lmax2 full example
"""
from aiida.orm import Code
from aiida.plugins import DataFactory
from masci_tools.io.kkr_params import kkrparams
from aiida_kkr.calculations.voro import VoronoiCalculation
Dict = DataFactory('dict')
StructureData = DataFactory('structure')
# create StructureData instance for Cu
alat = 3.61 # lattice constant in Angstroem
bravais = [[0.5 * alat, 0.5 * alat, 0], [0.5 * alat, 0, 0.5 * alat],
[0, 0.5 * alat, 0.5 * alat]] # Bravais matrix in Ang. units
Cu = StructureData(cell=bravais)
Cu.append_atom(position=[0, 0, 0], symbols='Cu')
# create Dict input node using kkrparams class from masci-tools
params = kkrparams(params_type='voronoi')
params.set_multiple_values(LMAX=2, NSPIN=1, RCLUSTZ=2.3)
Dict = DataFactory(
'dict') # use DataFactory to get ParamerterData class
ParaNode = Dict(dict=params.get_dict())
# import computer etc from database dump
from aiida.tools.importexport import import_data
import_data('files/db_dump_vorocalc.tar.gz')
# prepare computer and code (needed so that
prepare_code(voro_codename, codelocation, computername, workdir)
# load code from database and create new voronoi calculation
#code = Code.get_from_string(codename)
code = Code.get_from_string(voro_codename + '@' + computername)
#code = Code.get_from_string('voronoi@localhost_new')
options = {
'resources': {
'num_machines': 1,
'tot_num_mpiprocs': 1
},
'queue_name': queuename
}
builder = VoronoiCalculation.get_builder()
builder.code = code
builder.metadata.options = options
builder.parameters = ParaNode
builder.structure = Cu
builder.metadata.dry_run = True
from aiida.engine import run
run(builder)
def main(raspa_code_label, cp2k_code_label):
"""Prepare inputs and submit the work chain."""
print("Testing BindingSite work chain (FF + DFT) for CO2 in Zn-MOF-74 ...")
print("[NOTE: this test will run on 4 cpus and take ca. 10 minutes]")
builder = BindingSiteWorkChain.get_builder()
builder.metadata.label = "test"
builder.raspa_base.raspa.code = Code.get_from_string(raspa_code_label)
builder.cp2k_base.cp2k.code = Code.get_from_string(cp2k_code_label)
builder.raspa_base.raspa.metadata.options = {
"resources": {
"num_machines": 1,
"tot_num_mpiprocs": 1,
},
"max_wallclock_seconds": 1 * 10 * 60,
}
builder.cp2k_base.cp2k.metadata.options = {
"resources": {
"num_machines": 1,
"tot_num_mpiprocs": 4,
},
"max_wallclock_seconds": 1 * 10 * 60,
}
builder.structure = CifData(file=os.path.abspath('data/Zn-MOF-74.cif'), label="Zn-MOF-74")
builder.molecule = Str('co2')
builder.parameters = Dict(
dict={
"ff_framework": "UFF", # (str) Forcefield of the structure.
"mc_steps": int(10), # (int) Number of MC cycles.
"temperature_list": [300, 150],
})
builder.protocol_tag = Str('test')
builder.cp2k_base.cp2k.parameters = Dict(dict={ # Lowering CP2K default setting for a faster test calculation
'FORCE_EVAL': {
'DFT': {
'SCF': {
'EPS_SCF': 1.0E-4,
'OUTER_SCF': {
'EPS_SCF': 1.0E-4,
},
},
},
},
'MOTION': {
'GEO_OPT': {
'MAX_ITER': 5
}
},
})
run(builder)
def run_multistage_h2om(cp2k_code):
"""Example usage: verdi run thistest.py cp2k@localhost"""
print(
"Testing CP2K multistage workchain on 2xH2O- (UKS, no need for smearing)..."
)
print("This is checking:")
print(" > unit cell resizing")
print(" > protocol modification")
print(" > cp2k calc modification")
atoms = ase.build.molecule('H2O')
atoms.center(vacuum=2.0)
structure = StructureData(ase=atoms)
protocol_mod = Dict(dict={
'settings_0': {
'FORCE_EVAL': {
'DFT': {
'MGRID': {
'CUTOFF': 300,
}
}
}
}
})
parameters = Dict(dict={
'FORCE_EVAL': {
'DFT': {
'UKS': True,
'MULTIPLICITY': 3,
'CHARGE': -2,
}
}
})
# Construct process builder
builder = Cp2kMultistageWorkChain.get_builder()
builder.structure = structure
builder.min_cell_size = Float(4.1)
builder.protocol_tag = Str('test')
builder.protocol_modify = protocol_mod
builder.cp2k_base.cp2k.parameters = parameters
builder.cp2k_base.cp2k.code = cp2k_code
builder.cp2k_base.cp2k.metadata.options.resources = {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
}
builder.cp2k_base.cp2k.metadata.options.max_wallclock_seconds = 1 * 3 * 60
run(builder)
def example_dft(g_code):
"""Run simple DFT calculation"""
print("Testing Gaussian Input Creation")
pwd = os.path.dirname(os.path.realpath(__file__))
# structure
structure = StructureData(
pymatgen_molecule=mg.Molecule.from_file('./ch4.xyz'))
# parameters
parameters = Dict(
dict={
'functional': 'PBE1PBE',
'basis_set': '6-31g',
'route_parameters': {
'nosymm': None,
'Output': 'WFX'
},
'input_parameters': {
'output.wfx': None
},
'link0_parameters': {
'%chk': 'mychk.chk',
'%mem': '100000kb',
'%nprocshared': '2'
},
})
# Construct process builder
builder = GaussianCalculation.get_builder()
builder.structure = structure
builder.parameters = parameters
builder.code = g_code
builder.metadata.options.resources = {
"num_machines": 1,
"num_mpiprocs_per_machine": 2,
"tot_num_mpiprocs": parameters['link0_parameters']['%nprocshared']
}
builder.metadata.options.max_memory_kb = int(
parameters['link0_parameters']['%mem'][:-2])
builder.metadata.options.max_wallclock_seconds = 3 * 60
builder.metadata.dry_run = True
builder.metadata.store_provenance = False
print("Submitted calculation...")
run(builder)
def main():
inputs = {
'a': Float(3.14),
'b': Int(4),
'c': Int(6)
}
results = run(SumWorkChain, **inputs)
print('Result of SumWorkChain: {}'.format(results))
results = run(ProductWorkChain, **inputs)
print('Result of ProductWorkChain: {}'.format(results))
results = run(SumProductWorkChain, **inputs)
print('Result of SumProductWorkChain: {}'.format(results))
def test_calculation_future_broadcasts(self):
"""Test calculation future broadcasts."""
manager = get_manager()
runner = manager.get_runner()
process = test_processes.DummyProcess()
# No polling
future = processes.futures.ProcessFuture(
pk=process.pid, loop=runner.loop, communicator=manager.get_communicator()
)
run(process)
calc_node = runner.run_until_complete(asyncio.wait_for(future, self.TIMEOUT))
self.assertEqual(process.node.pk, calc_node.pk)
def test_process(rhino_zfs_code):
"""Test running a calculation
note this does not test that the expected outputs are created of output parsing"""
from aiida.plugins import DataFactory, CalculationFactory
from aiida.engine import run
# Prepare input parameters
DiffParameters = DataFactory('rhino_zfs')
parameters = DiffParameters({'ignore-case': True})
from aiida.orm import SinglefileData
file1 = SinglefileData(
file=os.path.join(TEST_DIR, "input_files", 'file1.txt'))
file2 = SinglefileData(
file=os.path.join(TEST_DIR, "input_files", 'file2.txt'))
# set up calculation
inputs = {
'code': rhino_zfs_code,
'parameters': parameters,
'file1': file1,
'file2': file2,
'metadata': {
'options': {
'max_wallclock_seconds': 30
},
},
}
result = run(CalculationFactory('rhino_zfs'), **inputs)
computed_diff = result['rhino_zfs'].get_content()
assert 'content1' in computed_diff
assert 'content2' in computed_diff
def run_wf(pwscf_code, pw2wannier90_code, wannier_code):
"""Run a simple workflow running Quantum ESPRESSO+wannier90 for GaAs."""
static_inputs = get_static_inputs()
pseudo_family_name = get_or_create_pseudo_family()
# Run the workflow
run(
MinimalW90WorkChain,
pw_code=pwscf_code, #load_code('pw-6.4-release@localhost'),
pseudo_family=Str(
pseudo_family_name), #Str('SSSP_efficiency_pseudos'),
wannier_code=wannier_code, #load_code('wannier90-3-desktop@localhost'),
pw2wannier90_code=
pw2wannier90_code, #load_code('pw2wannier90-6.4-release@localhost'),
**static_inputs)
def test_workchain_run(test_crystal_code, crystal_calc_parameters,
test_properties_code, properties_calc_parameters,
test_basis):
from mpds_aiida.workflows.crystal import MPDSCrystalWorkchain
from aiida.plugins import DataFactory
from aiida.engine import run
inputs = MPDSCrystalWorkchain.get_builder()
inputs.crystal_code = test_crystal_code
inputs.properties_code = test_properties_code
inputs.crystal_parameters = crystal_calc_parameters
inputs.properties_parameters = properties_calc_parameters
inputs.basis_family = test_basis
inputs.mpds_query = DataFactory('dict')(dict={
"classes": "binary",
"formulae": "MgO",
"sgs": 225
}) # MgO 225
inputs.options = DataFactory('dict')(dict={
'label': 'MgO/225/PS',
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 1
}
})
results = run(MPDSCrystalWorkchain, **inputs)
assert 'output_parameters' in results
assert 'frequency_parameters' in results
assert 'elastic_parameters' in results
assert 'output_dos' in results
assert 'output_bands' in results
def test_strained_fp_tb(
configure_with_daemon, # pylint: disable=unused-argument
get_optimize_fp_tb_input, # pylint: disable=redefined-outer-name
):
"""
Run the DFT tight-binding optimization workflow with strain on an InSb sample for three strain values.
"""
from aiida.engine import run
from aiida.orm import Code
from aiida.orm import Str, List
from aiida_tbextraction.optimize_strained_fp_tb import OptimizeStrainedFirstPrinciplesTightBinding
inputs = get_optimize_fp_tb_input
inputs['strain_kind'] = Str('three_five.Biaxial001')
inputs['strain_parameters'] = Str('InSb')
strain_strengths = List()
strain_list = [-0.1, 0., 0.1]
strain_strengths.extend(strain_list)
inputs['strain_strengths'] = strain_strengths
inputs['symmetry_repr_code'] = Code.get_from_string('symmetry_repr')
result = run(OptimizeStrainedFirstPrinciplesTightBinding, **inputs)
print(result)
for value in strain_list:
suffix = '_{}'.format(value).replace('.', '_dot_')
assert all(key + suffix in result
for key in ['cost_value', 'tb_model', 'window'])
def test_process(logger_code):
"""
Test running a calculation.
Also checks its outputs.
"""
from aiida.plugins import DataFactory, CalculationFactory
from aiida.engine import run
from aiida.common.extendeddicts import AttributeDict
from aiida_logger.tests import TEST_DIR # pylint: disable=wrong-import-position
# Prepare input parameters
parameters = AttributeDict()
parameters.comment_string = '#'
parameters.labels = True
# Define input files to use
SinglefileData = DataFactory('singlefile')
datafile = SinglefileData(
file=os.path.join(TEST_DIR, 'input_files', 'datafile'))
# Set up calculation
inputs = {
'code': logger_code,
'parameters': DataFactory('dict')(dict=parameters),
'datafiles': {
'datafile': datafile
},
'metadata': {
'options': {
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 1
},
'parser_name': 'logger',
'withmpi': False,
'output_filename': 'logger.out'
},
'description': 'Test job submission with the aiida_logger plugin'
},
}
result = run(CalculationFactory('logger'), **inputs)
assert 'data' in result
assert 'metadata' in result
data = result['data']
metadata = result['metadata']
metadata = metadata.get_dict()
assert 'labels' in metadata
assert 'comments' in metadata
assert metadata['labels'] == ['time', 'param1', 'param2', 'param3']
assert metadata['comments'][0] == '# This is an example file'
test_array = np.array([[1.0e+00, 3.0e+00, 4.0e+00, 5.0e+00],
[2.0e+00, 4.0e+00, 5.7e+00, -1.0e-01],
[3.0e+00, 1.0e-03, 1.0e+03, 8.0e-01]])
np.testing.assert_allclose(data.get_array('content'), test_array)
