def call_on_legacy_workflow_finish(self, pk, callback):
"""
Callback to be called when the workflow of the given pk is terminated
:param pk: the pk of the workflow
:param callback: the function to be called upon workflow termination
"""
workflow = load_workflow(pk=pk)
self._poll_legacy_wf(workflow, callback)
def run_ph(self):
main_params = self.get_parameters()
try:
pw_calculation = main_params['pw_calculation']
except KeyError:
wf_pw = ([
load_workflow(pk)
for pk in self.get_attributes().get('old_pw_wfs', [])
] + list(self.get_step(self.run_pw).get_sub_workflows()))[0]
pw_calculation = wf_pw.get_result('pw_calculation')
# Save results of the subworkflow in the main
for k, v in wf_pw.get_results().iteritems():
self.add_result(k, v)
# load the PhWorkflow parameters
ph_params = {'pw_calculation': pw_calculation}
for k, v in main_params.iteritems():
if k.startswith('ph_'):
new_k = k[3:] # remove ph_
ph_params[new_k] = v
# deactivate dielectric constant calculation if pw calculation done
# with a smearing (metal)
if pw_calculation.res.smearing_method:
ph_params['parameters']['INPUTPH']['epsil'] = False
self.append_to_report(
"Pw calculation (pk: {}) done with smearing -> "
"forcing epsil=False for Ph calculation".format(
pw_calculation.pk))
# Launch the PH sub-workflow
wf_ph = PhWorkflow(params=ph_params)
wf_ph.store()
self.append_to_report("Launching PH sub-workflow (pk: {})".format(
wf_ph.pk))
self.attach_workflow(wf_ph)
wf_ph.start()
if any([k.startswith('dispersion') for k in main_params.keys()]):
self.next(self.run_q2r)
return
else:
self.next(self.final_step_ph)
return
load_dbenv()
from aiida.orm import load_node, load_workflow
from aiida.orm import Code, DataFactory
import matplotlib.pyplot as plt
StructureData = DataFactory('structure')
ParameterData = DataFactory('parameter')
ArrayData = DataFactory('array')
KpointsData = DataFactory('array.kpoints')
import numpy as np
#######################
wf = load_workflow(1099)
#######################
thermal_properties = wf.get_result('thermal_properties')
energy = thermal_properties.get_array('electronic_energies')
volumes = thermal_properties.get_array('volumes')
entropy = thermal_properties.get_array('entropy')
cv = thermal_properties.get_array('cv')
temperature = thermal_properties.get_array('temperature')
plt.figure(1)
plt.plot(volumes, energy)
plt.figure(2)
def _get_wf_outputs(pk):
return load_workflow(pk=pk).get_results()
def test_load_workflows(self):
"""
Test for load_node() function.
"""
from aiida.orm import load_workflow
a = WorkflowTestEmpty()
a.store()
self.assertEquals(a.pk, load_workflow(wf_id=a.pk).pk)
self.assertEquals(a.pk, load_workflow(wf_id=a.uuid).pk)
self.assertEquals(a.pk, load_workflow(pk=a.pk).pk)
self.assertEquals(a.pk, load_workflow(uuid=a.uuid).pk)
with self.assertRaises(ValueError):
load_workflow(wf_id=a.pk, pk=a.pk)
with self.assertRaises(ValueError):
load_workflow(pk=a.pk, uuid=a.uuid)
with self.assertRaises(ValueError):
load_workflow(pk=a.uuid)
with self.assertRaises(ValueError):
load_workflow(uuid=a.pk)
with self.assertRaises(ValueError):
load_workflow()
load_dbenv()
from aiida.orm import load_node, load_workflow
from aiida.orm import Code, DataFactory
import matplotlib.pyplot as plt
StructureData = DataFactory('structure')
ParameterData = DataFactory('parameter')
ArrayData = DataFactory('array')
KpointsData = DataFactory('array.kpoints')
import numpy as np
#######################
wf = load_workflow(512)
#######################
wf_list = list(wf.get_step('pressure_expansions').get_sub_workflows())[:-1]
wf_list += list(wf.get_step('start').get_sub_workflows())
print wf_list[0].get_result('band_structure').get_array('q_points')[1][-1]
band = 4
volume = []
energy = []
grune_qpoint = []
for wf_grune in wf_list:
volume.append(wf_grune.get_result('final_structure').get_cell_volume())
energy.append(wf_grune.get_result('optimized_structure_data').dict.energy)
grune_qpoint.append(
from aiida.orm import load_node, load_workflow
from aiida.orm import Code, DataFactory
import matplotlib.pyplot as plt
StructureData = DataFactory('structure')
ParameterData = DataFactory('parameter')
ArrayData = DataFactory('array')
KpointsData = DataFactory('array.kpoints')
import numpy as np
# Set WorkflowPhonon PK number
########################
wf = load_workflow(9905)
########################
# Phonon Band structure
bs = wf.get_result('band_structure')
for i, freq in enumerate(bs.get_array('frequencies')):
plt.plot(bs.get_array('q_path')[i], freq, color='r')
plt.figure(1)
plt.axes().get_xaxis().set_ticks([])
plt.ylabel('Frequency [THz]')
plt.xlabel('Wave vector')
plt.xlim([0, bs.get_array('q_path')[-1][-1]])
plt.axhline(y=0, color='k', ls='dashed')
plt.suptitle('Phonon band structure')
def phonopy_merge(**kwargs):
from phonopy.structure.atoms import Atoms as PhonopyAtoms
from phonopy import Phonopy
from phonopy.units import VaspToTHz
from phonopy.harmonic.dynmat_to_fc import get_commensurate_points, DynmatToForceConstants
structure = kwargs.pop('structure')
phonopy_input = kwargs.pop('phonopy_input').get_dict()
harmonic = kwargs.pop('harmonic')
renormalized = kwargs.pop('renormalized')
eigenvectors = harmonic.get_array('eigenvectors')
frequencies = harmonic.get_array('frequencies')
shifts = renormalized.get_array('shifts')
# Generate phonopy phonon object
bulk = PhonopyAtoms(symbols=[site.kind_name for site in structure.sites],
positions=[site.position for site in structure.sites],
cell=structure.cell)
phonon = Phonopy(bulk,
phonopy_input['supercell'],
primitive_matrix=phonopy_input['primitive'],
distance=phonopy_input['distance'])
primitive = phonon.get_primitive()
supercell = phonon.get_supercell()
total_frequencies = frequencies + shifts
dynmat2fc = DynmatToForceConstants(primitive, supercell)
dynmat2fc.set_dynamical_matrices(total_frequencies / VaspToTHz, eigenvectors)
dynmat2fc.run()
total_force_constants = dynmat2fc.get_force_constants()
# Stores DOS data in DB as a workflow result
total_data = ArrayData()
total_data.set_array('force_constants', total_force_constants)
return {'final_results': total_data}
# Start script here
# Workflow phonon (at given volume)
wf = load_workflow(431)
parameters = wf.get_parameters()
results = wf.get_results()
inline_params = {'structure': results['final_structure'],
'phonopy_input': parameters['phonopy_input'],
'force_constants': results['force_constants']}
harmonic = phonopy_commensurate_inline(**inline_params)
# At reference volume (at T = 0)
wf = load_workflow(432)
parameters = wf.get_parameters()
results_r = wf.get_results()
results_h = wf.get_results()
inline_params = {'structure': results_h['final_structure'],
'phonopy_input': parameters['phonopy_input'],
'force_constants': results_h['force_constants'],
'r_force_constants': results_r['r_force_constants']}
renormalized = phonopy_commensurate_shifts_inline(**inline_params)
inline_params = {'structure': results_h['final_structure'],
'phonopy_input': parameters['phonopy_input'],
'harmonic': harmonic,
'renormalized': renormalized}
total = phonopy_merge(**inline_params)
print total
inline_params = {'structure': results_h['final_structure'],
'phonopy_input': parameters['phonopy_input'],
'force_constants': total['force_constants']}
results = phonopy_calculation_inline(**inline_params)[1]
band = results['band_structure']
# Phonon Band structure plot
plot_data(results['band_structure'])
def _get_wf_outputs(pk):
"""
Return the results dictionary of a legacy workflow
"""
return load_workflow(pk=pk).get_results()
qha_output.set_array('temperature', np.array(qha_temperatures))
qha_output.set_array('helmholtz_volume', np.array(helmholtz_volume))
qha_output.set_array('thermal_expansion', np.array(thermal_expansion))
qha_output.set_array('volume_temperature', np.array(volume_temperature))
qha_output.set_array('heat_capacity_P_numerical',
np.array(heat_capacity_P_numerical))
qha_output.set_array('volume_expansion', np.array(volume_expansion))
qha_output.set_array('gibbs_temperature', np.array(gibbs_temperature))
qha_output.store()
return {'qha_data': qha_output}
#######################
wf = load_workflow(910)
#######################
wf_parameters = wf.get_parameters()
# self.get_step_calculations(self.optimize).latest('id')
interval = wf.get_attribute('interval')
max = wf.get_attribute('max')
min = wf.get_attribute('min')
n_points = int((max - min) / interval) + 1
test_pressures = [min + interval * i for i in range(n_points)]
# Remove duplicates
#!/usr/bin/env python
from aiida import load_dbenv
load_dbenv()
from aiida.orm import load_node, load_workflow
import numpy as np
from phonopy.structure.atoms import Atoms as PhonopyAtoms
from phonopy import Phonopy
# Set WorkflowPhonon PK number
#######################
wf = load_workflow(437)
#######################
print('Results pk: {}'.format(wf.get_result('force_constants').pk))
# 1) Calculated and stored in database
# DOS
if True:
f = open('density_of_states', 'w')
print('Writing density of states')
for i, j in zip(
wf.get_result('dos').get_array('frequency'),
wf.get_result('dos').get_array('total_dos')):
f.write('{} {}\n'.format(i, j))
f.close()
# PARTIAL DOS
if True:
'$')
else:
labels_e.append('$' +
labels[i - 1][1].replace('GAMMA', '\Gamma') +
'/' + labels[i][0].replace('GAMMA', '\Gamma') +
'$')
x_labels.append(q_path[i][0])
x_labels.append(q_path[-1][-1])
labels_e.append('$' + labels[-1][1].replace('GAMMA', '\Gamma') + '$')
labels_e[0] = '$' + labels[0][0].replace('GAMMA', '\Gamma') + '$'
plt.xticks(x_labels, labels_e, rotation='horizontal')
#######################
wf = load_workflow(276)
#######################
# Band structure
bs = wf.get_result('band_structure')
plt.figure(1)
get_plot(bs.get_array('frequencies'),
bs.get_array('q_path'),
title='Phonon band structure',
ylabel='Frequency [THz]',
labels=bs.get_array('labels'))
plt.figure(2)
get_plot(bs.get_array('eigenvalues'),