def run_afms(self):
self.report("Running PP")
afm_pp_inputs = {}
afm_pp_inputs['_label'] = "afm_pp"
afm_pp_inputs['code'] = self.inputs.afm_pp_code
afm_pp_inputs['parameters'] = self.inputs.afm_pp_params
afm_pp_inputs['parent_calc_folder'] = self.ctx.scf_diag.out.remote_folder
afm_pp_inputs['atomtypes'] = SinglefileData(file="/project/apps/scanning_probe/afm/atomtypes_pp.ini")
afm_pp_inputs['_options'] = {
"resources": {"num_machines": 1},
"max_wallclock_seconds": 7200,
}
self.report("Afm pp inputs: " + str(afm_pp_inputs))
afm_pp_future = submit(AfmCalculation.process(), **afm_pp_inputs)
self.to_context(afm_pp=Calc(afm_pp_future))
self.report("Running 2PP")
afm_2pp_inputs = {}
afm_2pp_inputs['_label'] = "afm_2pp"
afm_2pp_inputs['code'] = self.inputs.afm_2pp_code
afm_2pp_inputs['parameters'] = self.inputs.afm_2pp_params
afm_2pp_inputs['parent_calc_folder'] = self.ctx.scf_diag.out.remote_folder
afm_2pp_inputs['atomtypes'] = SinglefileData(file="/project/apps/scanning_probe/afm/atomtypes_2pp.ini")
afm_2pp_inputs['_options'] = {
"resources": {"num_machines": 1},
"max_wallclock_seconds": 7200,
}
self.report("Afm 2pp inputs: " + str(afm_2pp_inputs))
afm_2pp_future = submit(AfmCalculation.process(), **afm_2pp_inputs)
self.to_context(afm_2pp=Calc(afm_2pp_future))
def setup(self):
"""
Launch the first calculation for the input structure,
and a second calculation for a shifted volume (increased by 4 angstrom^3)
Store the outputs of the two calcs in r0 and r1
"""
print "Workchain node identifiers: {}".format(self.calc)
inputs0 = generate_scf_input_params(self.inputs.structure,
str(self.inputs.code),
self.inputs.pseudo_family)
initial_volume = self.inputs.structure.get_cell_volume()
new_volume = initial_volume + 4. # In ang^3
scaled_structure = get_structure(self.inputs.structure, new_volume)
inputs1 = generate_scf_input_params(scaled_structure,
str(self.inputs.code),
self.inputs.pseudo_family)
self.ctx.last_structure = scaled_structure
# Run PW
future0 = submit(PwProcess, **inputs0)
future1 = submit(PwProcess, **inputs1)
# Wait to complete before next step
return ToContext(r0=future0, r1=future1)
def run_export_orbitals(self):
self.report("Running pp.x to export KS orbitals")
inputs = {}
inputs['_label'] = "export_orbitals"
inputs['code'] = self.inputs.pp_code
prev_calc = self.ctx.bands_lowres
self._check_prev_calc(prev_calc)
inputs['parent_folder'] = prev_calc.out.remote_folder
nel = prev_calc.res.number_of_electrons
nkpt = prev_calc.res.number_of_k_points
nbnd = prev_calc.res.number_of_bands
nspin = prev_calc.res.number_of_spin_components
volume = prev_calc.res.volume
#for....
kband1 = max(int(nel/2) - 6, 1)
kband2 = min(int(nel/2) + 7, nbnd)
kpoint1 = 1
kpoint2 = nkpt * nspin
nhours = 8 #24# 2 + min(22, 2*int(volume/1500))
for inb in range(kband1,kband2+1):
parameters = ParameterData(dict={
'inputpp': {
# contribution of a selected wavefunction
# to charge density
'plot_num': 7,
'kpoint(1)': kpoint1,
'kpoint(2)': kpoint2,
#'kband(1)': kband1,
#'kband(2)': kband2,
'kband(1)': inb,
'kband(2)': inb,
},
'plot': {
'iflag': 3, # 3D plot
'output_format': 6, # CUBE format
'fileout': '_orbital.cube',
},
})
inputs['parameters'] = parameters
inputs['_options'] = {
"resources": {"num_machines": 1},
"max_wallclock_seconds": nhours * 60 * 60, # 6 hours
"append_text": self._get_cube_cutter(),
}
settings = ParameterData(
dict={'additional_retrieve_list': ['*.cube.gz']}
)
inputs['settings'] = settings
#future = submit(PpCalculation.process(), **inputs)
submit(PpCalculation.process(), **inputs)
#return ToContext(orbitals=Calc(future))
return
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_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()
submit(JobCalc, **inputs)
def test_multiple_processes(self):
submit(DummyProcess, _jobs_store=self.storage)
submit(ExceptionProcess, _jobs_store=self.storage)
submit(ExceptionProcess, _jobs_store=self.storage)
submit(DummyProcess, _jobs_store=self.storage)
self.assertFalse(
daemon.tick_workflow_engine(self.storage, print_exceptions=False))
def launch(code, structure, pseudo_family, daemon, protocol):
"""
Run the PwBandStructureWorkChain for a given input structure
to compute the band structure for the relaxed structure
"""
from aiida.orm.data.base import Str
from aiida.orm.utils import WorkflowFactory
from aiida.work.run import run, submit
PwBandStructureWorkChain = WorkflowFactory(
'quantumespresso.pw.band_structure')
inputs = {
'code': code,
'structure': structure,
'pseudo_family': Str(pseudo_family),
'protocol': Str(protocol),
}
if daemon:
workchain = submit(PwBandStructureWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(
PwBandStructureWorkChain.__name__, workchain.pid))
else:
run(PwBandStructureWorkChain, **inputs)
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 launch(
code, parent_calc, kpoints, max_num_machines, max_wallclock_seconds, daemon):
"""
Run the MatdynBaseWorkChain for a previously completed Q2rCalculation
"""
from aiida.orm.data.parameter import ParameterData
from aiida.orm.utils import CalculationFactory, WorkflowFactory
from aiida.work.run import run, submit
from aiida_quantumespresso.utils.resources import get_default_options
MatdynBaseWorkChain = WorkflowFactory('quantumespresso.matdyn.base')
options = get_default_options(max_num_machines, max_wallclock_seconds)
inputs = {
'code': code,
'kpoints': kpoints,
'parent_folder': parent_calc.out.force_constants,
'options': ParameterData(dict=options),
}
if daemon:
workchain = submit(MatdynBaseWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(MatdynBaseWorkChain.__name__, workchain.pid))
else:
run(MatdynBaseWorkChain, **inputs)
def run_cellopt_init(self):
"""Run CELL_OPT calculation."""
# For the first time we do wery rough cell optimization with only 20 steps max and keeping angles fixed.
geo_motion = {
'MOTION': {
'CELL_OPT': {
'MAX_ITER': 20,
'KEEP_ANGLES': True,
},
},
}
dict_merge(geo_motion, self.ctx.last_dft_dict)
inputs = {
'code':
self.inputs.code,
'structure':
self.ctx.structure,
'parameters':
merge_ParameterData(self.ctx.parameters,
ParameterData(dict=geo_motion)),
'_options':
self.inputs._options,
'_label':
'Stage1_CellOpt',
}
# restart wavefunctions if they are provided
if self.ctx.restart_calc:
inputs['parent_folder'] = self.ctx.restart_calc
# run the calculation
running = submit(Cp2kCellOptWorkChain, **inputs)
self.report("pk: {} | Running cp2k CELL_OPT".format(running.pid))
return ToContext(cp2k=Outputs(running))
def run_extmol(self):
"""
Run the SiestaBaseWorkChain to calculate the extended molecule
structure
"""
self.report('Running run_extmol')
siesta_inputs = dict(self.ctx.siesta_inputs)
rem_inputs = {}
rem_inputs['code'] = siesta_inputs['siesta_code']
rem_inputs['kpoints'] = self.ctx.kpoints_em
rem_inputs['basis'] = ParameterData(dict=siesta_inputs['basis'])
rem_inputs['structure'] = self.ctx.structure_em
rem_inputs['pseudos'] = siesta_inputs['pseudos']
rem_inputs['parameters'] = ParameterData(
dict=siesta_inputs['parameters'])
rem_inputs['settings'] = ParameterData(dict=siesta_inputs['settings'])
rem_inputs['clean_workdir'] = Bool(False)
rem_inputs['max_iterations'] = Int(20)
rem_inputs['options'] = siesta_inputs['options']
running = submit(SiestaBaseWorkChain, **rem_inputs)
self.report(
'launched SiestaBaseWorkChain<{}> in run-Siesta mode'.format(
running.pid))
return ToContext(workchain_extmol=running)
def get_dos(self):
"""
submit a dos calculation and interpolate result if returns complete
"""
label = 'KKR DOS calc.'
dosdict = self.ctx.dos_params_dict
description = 'dos calculation using the following parameter set. emin= {}, emax= {}, nepts= {}, tempr={}, kmesh={}'.format(
dosdict['emin'], dosdict['emax'], dosdict['nepts'],
dosdict['tempr'], dosdict['kmesh'])
code = self.inputs.kkr
remote = self.inputs.remote_data
params = self.ctx.dos_kkrparams
options = {
"max_wallclock_seconds": self.ctx.walltime_sec,
"resources": self.ctx.resources,
"queue_name": self.ctx.queue
} #,
if self.ctx.custom_scheduler_commands:
options[
"custom_scheduler_commands"] = self.ctx.custom_scheduler_commands
inputs = get_inputs_kkr(code,
remote,
options,
label,
description,
parameters=params,
serial=(not self.ctx.use_mpi))
# run the DOS calculation
self.report('INFO: doing calculation')
dosrun = submit(KkrProcess, **inputs)
return ToContext(dosrun=dosrun)
def run_zeopp(self):
"""Main function that performs zeo++ VOLPO and block calculations."""
params = {
'ha': True,
#100 samples / Ang^3: accurate for all the structures
'block': [self.inputs.zeopp_probe_radius.value, 100],
#100k samples, may need more for structures bigger than 30x30x30
'volpo': [self.inputs.zeopp_probe_radius.value,
self.inputs.zeopp_probe_radius.value, 100000]
}
inputs = {
'code' : self.inputs.zeopp_code,
'structure' : self.inputs.structure,
'parameters' : NetworkParameters(dict=params).store(),
'_options' : self.inputs._zeopp_options,
'_label' : "ZeoppVolpoBlock",
}
# Use default zeopp atomic radii only if a .rad file is not specified
try:
inputs['atomic_radii'] = self.inputs.zeopp_atomic_radii
self.report("Zeopp will use atomic radii from the .rad file")
except:
self.report("Zeopp will use default atomic radii")
# Create the calculation process and launch it
running = submit(ZeoppCalculation.process(), **inputs)
self.report("pk: {} | Running zeo++ volpo and block calculations".format(running.pid))
return ToContext(zeopp=Outputs(running))
def run_zeopp(self):
self.report("Running workchain for structure {}".format(
self.inputs.structure.filename))
label = "zeopp"
inputs = {}
inputs['_label'] = label
inputs['_description'] = "Sampling accessible pore surface with zeo++"
inputs['code'] = self.inputs.zeopp_code
inputs['structure'] = self.inputs.structure
NetworkParameters = DataFactory('zeopp.parameters')
network_dict = {
'cssr': True,
'ha': True,
'vsa': [1.8, 1.8, 1000],
'sa': [1.8, 1.8, 1000],
}
inputs['parameters'] = NetworkParameters(dict=network_dict)
inputs['_options'] = self.default_options
NetworkCalculation = CalculationFactory('zeopp.network')
future = submit(NetworkCalculation.process(), **inputs)
self.report(
"pk: {} | Submitted zeo++ calculation for structure {}".format(
future.pid, self.inputs.structure.filename))
return ToContext(**{label: Outputs(future)})
def run_inpgen(self):
"""
So far run inpgen and see what you get
"""
structure = self.inputs.structure
self.ctx.formula = structure.get_formula()
label = 'scf: inpgen'
description = '{} inpgen on {}'.format(self.ctx.description_wf,
self.ctx.formula)
inpgencode = self.inputs.inpgen
if 'calc_parameters' in self.inputs:
params = self.inputs.calc_parameters
else:
params = None
options = {
"max_wallclock_seconds": self.ctx.walltime_sec,
"resources": self.ctx.resources,
"queue_name": self.ctx.queue
}
inputs = get_inputs_inpgen(structure,
inpgencode,
options,
label,
description,
params=params)
self.report('INFO: run inpgen')
future = submit(FleurinpProcess, **inputs)
return ToContext(inpgen=future, last_calc=future)
def run_relax(self):
"""
Run the PwRelaxWorkChain to run a relax PwCalculation
"""
inputs = self.inputs.relax
inputs.update({
'code': self.inputs.code,
'structure': self.inputs.structure,
'pseudo_family': self.inputs.pseudo_family,
})
# If options set, add it to the default inputs
if 'options' in self.inputs:
inputs['options'] = self.inputs.options
# If automatic parallelization was set, add it to the default inputs
if 'automatic_parallelization' in self.inputs:
inputs[
'automatic_parallelization'] = self.inputs.automatic_parallelization
running = submit(PwRelaxWorkChain, **inputs)
self.report('launching PwRelaxWorkChain<{}>'.format(running.pid))
return ToContext(workchain_relax=running)
def run_geo_opt(self):
"""Optimize the geometry using the robust 5 steps process"""
self.ctx.structure = multiply_unit_cell(self.inputs.structure, self.inputs.min_cell_size)
cp2k_parameters = deepcopy(self.inputs.cp2k_parameters.get_dict())
# Expand the unit cell so that: min(perpendicular_width) > threshold
inputs = {
'code' : self.inputs.cp2k_code,
'structure' : self.ctx.structure,
'min_cell_size' : self.inputs.min_cell_size,
'_options' : self.inputs._cp2k_options,
'_label' : "Cp2kRobustGeoOptWorkChain",
}
# Trying to guess the multiplicity of the system
if self.inputs._guess_multiplicity:
self.report("Guessing multiplicity")
dict_merge(cp2k_parameters, guess_multiplicity(self.ctx.structure).get_dict())
# Take parameters
self.ctx.cp2k_parameters = ParameterData(dict=cp2k_parameters)
inputs['parameters'] = self.ctx.cp2k_parameters
# Create the calculation process and launch it
running = submit(Cp2kRobustGeoOptWorkChain, **inputs)
self.report("pk: {} | Running Cp2kRobustGeoOptWorkChain to optimize geometry".format(running.pid))
return ToContext(geo_opt_calc=Outputs(running))
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_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_fleurinpgen(self):
"""
run the inpgen
"""
structure = self.inputs.structure
inpgencode = self.inputs.inpgen
if 'calc_parameters' in self.inputs:
params = self.inputs.calc_parameters
else:
params = None
options = {
"max_wallclock_seconds": self.ctx.walltime_sec,
"resources": self.ctx.resources,
"queue_name": self.ctx.queue
}
inputs = get_inputs_inpgen(structure,
inpgencode,
options,
params=params)
print 'run inpgen'
future = submit(FleurinpProcess, **inputs)
return ToContext(inpgen=future, last_calc=future)
def run_ph(self):
"""
Run a PhCalculation either starting from a previous PwCalculation or restarting from a
previous PhCalculation run in this workchain
"""
self.ctx.iteration += 1
# Create local copy of general inputs stored in the context and adapt for next calculation
inputs = dict(self.ctx.inputs)
if isinstance(self.ctx.restart_calc, PhCalculation):
inputs['parameters']['INPUTPH']['recover'] = True
elif isinstance(self.ctx.restart_calc, PwCalculation):
pass
else:
ctype = type(self.ctx.restart_calc)
self.abort_nowait(
"The type '{}' of the parent calculation is invalid".format(
ctype))
inputs['parent_folder'] = self.ctx.restart_calc.out.remote_folder
inputs['parameters'] = ParameterData(dict=inputs['parameters'])
inputs['settings'] = ParameterData(dict=inputs['settings'])
process = PhCalculation.process()
running = submit(process, **inputs)
self.report('launching PhCalculation<{}> iteration #{}'.format(
running.pid, self.ctx.iteration))
return ToContext(calculations=append_(running))
def run_bands(self):
"""
Run the PwBaseWorkChain to run a bands PwCalculation along the path of high-symmetry determined by Seekpath
"""
try:
remote_folder = self.ctx.workchain_scf.out.remote_folder
except AttributeError as exception:
self.abort_nowait(
'the scf workchain did not output a remote_folder node')
return
inputs = self.ctx.inputs
restart_mode = 'restart'
calculation_mode = 'bands'
# Set the correct pw.x input parameters
inputs.parameters['CONTROL']['restart_mode'] = restart_mode
inputs.parameters['CONTROL']['calculation'] = calculation_mode
if 'kpoints' in self.inputs:
inputs.kpoints = self.inputs.kpoints
else:
inputs.kpoints = self.ctx.kpoints_path
inputs.structure = self.ctx.structure
inputs.parent_folder = remote_folder
inputs = prepare_process_inputs(inputs)
running = submit(PwBaseWorkChain, **inputs)
self.report('launching PwBaseWorkChain<{}> in {} mode'.format(
running.pid, calculation_mode))
return ToContext(workchain_bands=running)
def optimize_cycle(self):
if not 'counter' in self.ctx:
self.ctx.counter = 0
self.ctx.counter += 1
# self.ctx._get_dict()
print ('start optimization')
if not 'optimize' in self.ctx:
structure = self.inputs.structure
else:
structure = parse_optimize_calculation(self.ctx.optimize)['output_structure']
if self.inputs.standarize_cell:
structure = standardize_cell(structure)['standardized_structure']
JobCalculation, calculation_input = generate_inputs(structure,
self.inputs.es_settings,
pressure=self.inputs.pressure,
type='optimize',
)
calculation_input._label = 'optimize'
future = submit(JobCalculation, **calculation_input)
self.report('optimize calculation pk = {}'.format(future.pid))
return ToContext(optimize=future)
def create_unit_cell_expansions(self):
print('start Gruneisen (pk={})'.format(self.pid))
print('start create cell expansions')
# For testing
testing = False
if testing:
self.ctx._content['plus'] = load_node(13603)
self.ctx._content['origin'] = load_node(13600)
self.ctx._content['minus'] = load_node(13606)
return
calcs = {}
for expansions in {'plus': float(self.inputs.pressure) + float(self.inputs.stress_displacement),
'origin': float(self.inputs.pressure),
'minus': float(self.inputs.pressure) - float(self.inputs.stress_displacement)}.items():
future = submit(PhononPhonopy,
structure=self.inputs.structure,
ph_settings=self.inputs.ph_settings,
es_settings=self.inputs.es_settings,
pressure=Float(expansions[1]),
optimize=Bool(True),
use_nac=self.inputs.use_nac
)
calcs[expansions[0]] = future
print ('phonon workchain: {} {}'.format(expansions[0], future.pid))
return ToContext(**calcs)
def run_geom_zeopp(self):
"""This is the main function that will perform a raspa calculation for the current pressure"""
# network parameters
sigma = self.inputs.probe_molecule.dict.sigma
NetworkParameters = DataFactory('zeopp.parameters')
params = NetworkParameters({
'ha': True,
'res': True,
'sa': [sigma, sigma, 100000],
'volpo': [sigma, sigma, 100000],
})
# Create the input dictionary
inputs = {
'code': self.inputs.zeopp_code,
'structure': self.ctx.structure,
'parameters': params,
'_options': self.inputs.zeopp_options.get_dict(),
'_label': "run_geom_zeopp",
}
# Create the calculation process and launch it
running = submit(ZeoppCalculation.process(), **inputs)
self.report("pk: {} | Running geometry analysis with zeo++".format(
running.pid))
return ToContext(zeopp=Outputs(running))
def run_henry_raspa(self):
"""This is the main function that will perform a raspaa 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': self.inputs.raspa_code,
'structure': self.ctx.structure,
'parameters': ParameterData(dict=raspa_parameters),
'options': self.inputs.raspa_options,
'_label': "run_henry_raspa",
}
# Create the calculation process and launch it
running = submit(RaspaConvergeWorkChain, **inputs)
self.report("pk: {} | Running raspa for the Henry coefficients".format(
running.pid))
return ToContext(raspa_henry=Outputs(running))
def run_raspa_gcmc(self):
"""Run a GCMC calculation in Raspa @ T,P. """
pressure = self.ctx.pressures[self.ctx.current_p_index]
self.ctx.raspa_parameters['GeneralSettings'][
'ExternalPressure'] = pressure
# Create the input dictionary
inputs = {
'code': self.inputs.raspa_code,
'structure': self.inputs.structure,
'parameters':
ParameterData(dict=self.ctx.raspa_parameters).store(),
'_options': self.inputs._raspa_options,
'_label': "RaspaGCMC",
}
# Check if there are poket blocks to be loaded
if self.ctx.number_blocking_spheres > 0:
inputs['block_component_0'] = self.ctx.zeopp['block']
# Check if there is a previous calculation (lower p) to restart from
if self.ctx.restart_raspa_calc is not None:
inputs['retrieved_parent_folder'] = self.ctx.restart_raspa_calc
# Create the calculation process and launch it
running = submit(RaspaConvergeWorkChain, **inputs)
self.report(
"pk: {} | Running Raspa GCMC at p(bar)={:.3f} ({} of {})".format(
running.pid, pressure / 1e5, self.ctx.current_p_index + 1,
len(self.ctx.pressures)))
return ToContext(raspa_gcmc=Outputs(running))
def run_raspa_widom(self):
"""Run a Widom calculation in Raspa."""
# Create the inputs dictionary
inputs = {
'code': self.inputs.raspa_code,
'structure': self.inputs.structure,
'parameters':
ParameterData(dict=self.ctx.raspa_parameters).store(),
'_options': self.inputs._raspa_options,
'_label': "RaspaWidom",
}
# Check if there are blocking spheres (reading the header of the file) and use them for Raspa
with open(self.ctx.zeopp['block'].get_abs_path() + '/path/' + \
self.ctx.zeopp['block'].get_folder_list()[0]) as f:
self.ctx.number_blocking_spheres = int(f.readline().strip())
if self.ctx.number_blocking_spheres > 0:
inputs['block_component_0'] = self.ctx.zeopp['block']
self.report(
"Blocking spheres ({}) are present and used for Raspa".format(
self.ctx.number_blocking_spheres))
else:
self.report("No blocking spheres found")
# Create the calculation process and launch it
running = submit(RaspaConvergeWorkChain, **inputs)
self.report(
"pk: {} | Running Raspa Widom for the Henry coefficient".format(
running.pid))
return ToContext(raspa_widom=Outputs(running))
def _submit_pw_calc(self,
structure,
label,
runtype,
wallhours=24,
parent_folder=None):
self.report("Running pw.x for " + label)
inputs = {}
inputs['_label'] = label
inputs['code'] = self.inputs.code
inputs['structure'] = structure
inputs['parameters'] = self._get_parameters(structure, runtype,
parent_folder)
inputs['pseudo'] = self._get_pseudos(
structure, family_name="SSSP_efficiency_v1.0")
if parent_folder:
inputs['parent_folder'] = parent_folder
# kpoints
kpoints = KpointsData()
kpoints_mesh = 2
kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh])
inputs['kpoints'] = kpoints
inputs['_options'] = {
"resources": {
"num_machines": 1,
"num_mpiprocs_per_machine": 1
},
"max_wallclock_seconds": wallhours * 60 * 60, # hours
}
future = submit(PwCalculation.process(), **inputs)
return ToContext(**{label: Calc(future)})
def run_loading_raspa(self):
"""This function will run RaspaConvergeWorkChain for the current pressure"""
pressure = self.ctx.pressures[self.ctx.current_p_index]
self.ctx.raspa_parameters['GeneralSettings'][
'ExternalPressure'] = pressure
parameters = ParameterData(dict=self.ctx.raspa_parameters).store()
# Create the input dictionary
inputs = {
'code': self.inputs.raspa_code,
'structure': self.ctx.structure,
'parameters': parameters,
'_options': self.inputs._raspa_options,
'_label': "run_loading_raspa",
}
# Check if there are poket blocks to be loaded
try:
inputs['block_component_0'] = self.ctx.zeopp_block['block']
except:
pass
if self.ctx.restart_raspa_calc is not None:
inputs['retrieved_parent_folder'] = self.ctx.restart_raspa_calc
# Create the calculation process and launch it
running = submit(RaspaConvergeWorkChain, **inputs)
self.report("pk: {} | Running raspa for the pressure {} [bar]".format(
running.pid, pressure / 1e5))
self.ctx.current_p_index += 1
return ToContext(raspa_loading=Outputs(running))
def submit_jobs(self):
print("structure PK: %i"%self.inputs.structure.pk)
grp, created = Group.get_or_create(name=self.inputs.group)
grp.add_nodes([self.calc])
print("stress tensor PK: %i"%self.calc.pk)
# get calculation class
C = CalculationFactory(self.inputs.code.get_input_plugin_name())
Proc = C.process()
num_points = 5
# volume scales from 0.94 to 1.06, alat scales as pow(1/3)
scales = numpy.linspace(0.94**(1/3.0), 1.06**(1/3.0), num_points).tolist()
calcs = {}
for scale in scales:
print("scale = %f"%scale)
# scaled structure
new_structure = scaled_structure(self.inputs.structure, Float(scale))
# basic parameters of the calculation
params = calculation_helpers.create_calculation_parameters(self.inputs.code,
str(self.inputs.partition),
int(self.inputs.ranks_per_node),
int(self.inputs.ranks_kp),
int(self.inputs.ranks_diag))
inputs = Proc.get_inputs_template()
inputs.code = self.inputs.code
inputs._options.resources = params['calculation_resources']
inputs._options.max_wallclock_seconds = 20 * 60
inputs._options.custom_scheduler_commands = params['custom_scheduler_commands']
inputs._options.environment_variables = params['environment_variables']
inputs._options.mpirun_extra_params = params['mpirun_extra_params']
inputs.structure = new_structure
inputs.kpoints = KpointsData()
inputs.kpoints.set_kpoints_mesh(self.inputs.kmesh, offset=(0.0, 0.0, 0.0))
inputs.parameters = params['calculation_parameters']
inputs.settings = params['calculation_settings']
if self.inputs.code.get_input_plugin_name() == 'quantumespresso.pw':
inputs.pseudo = get_pseudos(new_structure, self.inputs.atomic_files)
if self.inputs.code.get_input_plugin_name() == 'exciting.exciting':
inputs.lapwbasis = get_lapwbasis(new_structure, self.inputs.atomic_files)
future = submit(Proc, **inputs)
