diff --git a/aiidalab_qe/app/__init__.py b/aiidalab_qe/app/__init__.py
deleted file mode 100644
index 45353d73..00000000
--- a/aiidalab_qe/app/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""Package for the AiiDAlab QE app."""
-
-from .process import WorkChainSelector
-from .steps import SubmitQeAppWorkChainStep, ViewQeAppWorkChainStatusAndResultsStep
-from .structures import StructureSelectionStep
-
-__all__ = [
- "StructureSelectionStep",
- "SubmitQeAppWorkChainStep",
- "ViewQeAppWorkChainStatusAndResultsStep",
- "WorkChainSelector",
-]
diff --git a/aiidalab_qe/app/steps.py b/aiidalab_qe/app/steps.py
deleted file mode 100644
index 14e2cfcb..00000000
--- a/aiidalab_qe/app/steps.py
+++ /dev/null
@@ -1,1401 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Widgets for the submission of bands work chains.
-
-Authors: AiiDAlab team
-"""
-from __future__ import annotations
-
-import os
-import typing as t
-from dataclasses import dataclass
-
-import ipywidgets as ipw
-import traitlets
-from aiida.common import NotExistent
-from aiida.engine import ProcessBuilderNamespace, ProcessState, submit
-from aiida.orm import WorkChainNode, load_code, load_node
-from aiida.plugins import DataFactory
-from aiida_quantumespresso.common.types import ElectronicType, RelaxType, SpinType
-from aiida_quantumespresso.workflows.pw.base import PwBaseWorkChain
-from aiidalab_widgets_base import (
- AiidaNodeViewWidget,
- ComputationalResourcesWidget,
- ProcessMonitor,
- ProcessNodesTreeWidget,
- WizardAppWidgetStep,
-)
-from IPython.display import clear_output, display
-
-from aiidalab_qe.app.parameters import DEFAULT_PARAMETERS
-from aiidalab_qe.app.pseudos import PseudoFamilySelector
-from aiidalab_qe.app.setup_codes import QESetupWidget
-from aiidalab_qe.app.sssp import SSSPInstallWidget
-from aiidalab_qe.app.widgets import ParallelizationSettings, ResourceSelectionWidget
-from aiidalab_qe.workflows import QeAppWorkChain
-
-StructureData = DataFactory("core.structure")
-Float = DataFactory("core.float")
-Dict = DataFactory("core.dict")
-Str = DataFactory("core.str")
-
-PROTOCOL_PSEUDO_MAP = {
- "fast": "SSSP/1.2/PBE/efficiency",
- "moderate": "SSSP/1.2/PBE/efficiency",
- "precise": "SSSP/1.2/PBE/precision",
-}
-
-
-# The static input parameters for the QE App WorkChain
-# The dataclass does not include codes and structure which will be set
-# from widgets separately.
-# Relax type, electronic type, spin type, are str because they are used also
-# for serialized input of extras attributes of the workchain
-@dataclass(frozen=True)
-class QeWorkChainParameters:
- protocol: str
- relax_type: str
- properties: t.List[str]
- spin_type: str
- electronic_type: str
- overrides: t.Dict[str, t.Any]
- initial_magnetic_moments: t.Dict[str, float]
-
-
-class WorkChainSettings(ipw.VBox):
- structure_title = ipw.HTML(
- """
-
Structure
"""
- )
- structure_help = ipw.HTML(
- """
- You have three options:
- (1) Structure as is: perform a self consistent calculation using the structure provided as input.
- (2) Atomic positions: perform a full relaxation of the internal atomic coordinates.
- (3) Full geometry: perform a full relaxation for both the internal atomic coordinates and the cell vectors.
"""
- )
- materials_help = ipw.HTML(
- """
- Below you can indicate both if the material should be treated as an insulator
- or a metal (if in doubt, choose "Metal"),
- and if it should be studied with magnetization/spin polarization,
- switch magnetism On or Off (On is at least twice more costly).
-
"""
- )
-
- properties_title = ipw.HTML(
- """
-
Properties
"""
- )
- properties_help = ipw.HTML(
- """
- The band structure workflow will
- automatically detect the default path in reciprocal space using the
-
- SeeK-path tool.
-
Protocol
"""
- )
- protocol_help = ipw.HTML(
- """
- The "moderate" protocol represents a trade-off between
- accuracy and speed. Choose the "fast" protocol for a faster calculation
- with less precision and the "precise" protocol to aim at best accuracy (at the price of longer/costlier calculations).
"""
- )
-
- def __init__(self, **kwargs):
- # RelaxType: degrees of freedom in geometry optimization
- self.relax_type = ipw.ToggleButtons(
- options=[
- ("Structure as is", "none"),
- ("Atomic positions", "positions"),
- ("Full geometry", "positions_cell"),
- ],
- value="positions_cell",
- )
-
- # SpinType: magnetic properties of material
- self.spin_type = ipw.ToggleButtons(
- options=[("Off", "none"), ("On", "collinear")],
- value=DEFAULT_PARAMETERS["spin_type"],
- style={"description_width": "initial"},
- )
-
- # ElectronicType: electronic properties of material
- self.electronic_type = ipw.ToggleButtons(
- options=[("Metal", "metal"), ("Insulator", "insulator")],
- value=DEFAULT_PARAMETERS["electronic_type"],
- style={"description_width": "initial"},
- )
-
- # Checkbox to see if the band structure should be calculated
- self.bands_run = ipw.Checkbox(
- description="",
- indent=False,
- value=True,
- layout=ipw.Layout(max_width="10%"),
- )
-
- # Checkbox to see if the PDOS should be calculated
- self.pdos_run = ipw.Checkbox(
- description="",
- indent=False,
- value=True,
- layout=ipw.Layout(max_width="10%"),
- )
-
- # Work chain protocol
- self.workchain_protocol = ipw.ToggleButtons(
- options=["fast", "moderate", "precise"],
- value="moderate",
- )
- super().__init__(
- children=[
- self.structure_title,
- self.structure_help,
- self.relax_type,
- self.materials_help,
- ipw.HBox(
- children=[
- ipw.Label(
- "Electronic Type:",
- layout=ipw.Layout(
- justify_content="flex-start", width="120px"
- ),
- ),
- self.electronic_type,
- ]
- ),
- ipw.HBox(
- children=[
- ipw.Label(
- "Magnetism:",
- layout=ipw.Layout(
- justify_content="flex-start", width="120px"
- ),
- ),
- self.spin_type,
- ]
- ),
- self.properties_title,
- ipw.HTML("Select which properties to calculate:"),
- ipw.HBox(children=[ipw.HTML("Band structure"), self.bands_run]),
- ipw.HBox(
- children=[
- ipw.HTML("Projected density of states"),
- self.pdos_run,
- ]
- ),
- self.properties_help,
- self.protocol_title,
- ipw.HTML("Select the protocol:", layout=ipw.Layout(flex="1 1 auto")),
- self.workchain_protocol,
- self.protocol_help,
- ],
- **kwargs,
- )
-
- def _update_settings(self, **kwargs):
- """Update the settings based on the given dict."""
- for key in [
- "relax_type",
- "spin_type",
- "electronic_type",
- "bands_run",
- "pdos_run",
- "workchain_protocol",
- ]:
- if key in kwargs:
- getattr(self, key).value = kwargs[key]
-
-
-class AdvancedSettings(ipw.VBox):
- title = ipw.HTML(
- """
-
Advanced Settings
"""
- )
- description = ipw.HTML("""Select the advanced settings for the pw.x code.""")
-
- def __init__(self, **kwargs):
- self.override = ipw.Checkbox(
- description="Override",
- indent=False,
- value=False,
- )
- self.smearing = SmearingSettings()
- self.kpoints = KpointSettings()
- self.tot_charge = TotalCharge()
- self.magnetization = MagnetizationSettings()
- self.list_overrides = [
- self.smearing.override,
- self.kpoints.override,
- self.tot_charge.override,
- self.magnetization.override,
- ]
- for override in self.list_overrides:
- ipw.dlink(
- (self.override, "value"),
- (override, "disabled"),
- lambda override: not override,
- )
- self.override.observe(self.set_advanced_settings, "value")
- super().__init__(
- children=[
- self.title,
- ipw.HBox(
- [
- self.description,
- self.override,
- ],
- ),
- self.tot_charge,
- self.magnetization,
- self.smearing,
- self.kpoints,
- ],
- layout=ipw.Layout(justify_content="space-between"),
- **kwargs,
- )
-
- def set_advanced_settings(self, _=None):
- self.smearing.reset()
- self.kpoints.reset()
- self.tot_charge.reset()
- self.magnetization.reset()
-
-
-class TotalCharge(ipw.VBox):
- """Widget to define the total charge of the simulation"""
-
- tot_charge_default = traitlets.Float(default_value=0.0)
-
- def __init__(self, **kwargs):
- self.override = ipw.Checkbox(
- description="Override",
- indent=False,
- value=False,
- )
- self.charge = ipw.BoundedFloatText(
- value=0,
- min=-3,
- max=3,
- step=0.01,
- disabled=False,
- description="Total charge:",
- style={"description_width": "initial"},
- )
- ipw.dlink(
- (self.override, "value"),
- (self.charge, "disabled"),
- lambda override: not override,
- )
- super().__init__(
- children=[
- ipw.HBox(
- [
- self.override,
- self.charge,
- ],
- ),
- ],
- layout=ipw.Layout(justify_content="space-between"),
- **kwargs,
- )
- self.charge.observe(self.set_tot_charge, "value")
- self.override.observe(self.set_tot_charge, "value")
-
- def set_tot_charge(self, _=None):
- self.charge.value = (
- self.charge.value if self.override.value else self.tot_charge_default
- )
-
- def _update_settings(self, **kwargs):
- """Update the override and override_tot_charge and override_tot_charge values by the given keyword arguments
- Therefore the override checkbox is not updated and defaults to True"""
- self.override.value = True
- with self.hold_trait_notifications():
- if "tot_charge" in kwargs:
- self.charge.value = kwargs["tot_charge"]
-
- def reset(self):
- with self.hold_trait_notifications():
- self.charge.value = self.tot_charge_default
- self.override.value = False
-
-
-class MagnetizationSettings(ipw.VBox):
- """Widget to set the initial magnetic moments for each kind names defined in the StructureData (StructureDtaa.get_kind_names())
- Usually these are the names of the elements in the StructureData
- (For example 'C' , 'N' , 'Fe' . However the StructureData can have defined kinds like 'Fe1' and 'Fe2')
-
- The widget generate a dictionary that can be used to set initial_magnetic_moments in the builder of PwBaseWorkChain
-
- Attributes:
- input_structure(StructureData): trait that containes the input_strucgure (confirmed structure from previous step)
- """
-
- input_structure = traitlets.Instance(StructureData, allow_none=True)
-
- def __init__(self, **kwargs):
- self.input_structure = StructureData()
- self.input_structure_labels = []
- self.description = ipw.HTML(
- "Define magnetization: Input structure not confirmed"
- )
- self.kinds = self.create_kinds_widget()
- self.kinds_widget_out = ipw.Output()
- self.override = ipw.Checkbox(
- description="Override",
- indent=False,
- value=False,
- )
- super().__init__(
- children=[
- ipw.HBox(
- [
- self.override,
- self.description,
- self.kinds_widget_out,
- ],
- ),
- ],
- layout=ipw.Layout(justify_content="space-between"),
- **kwargs,
- )
- self.display_kinds()
- self.override.observe(self._disable_kinds_widgets, "value")
-
- def _disable_kinds_widgets(self, _=None):
- for i in range(len(self.kinds.children)):
- self.kinds.children[i].disabled = not self.override.value
-
- def reset(self):
- self.override.value = False
- if hasattr(self.kinds, "children") and self.kinds.children:
- for i in range(len(self.kinds.children)):
- self.kinds.children[i].value = 0.0
-
- def create_kinds_widget(self):
- if self.input_structure_labels:
- widgets_list = []
- for kind_label in self.input_structure_labels:
- kind_widget = ipw.BoundedFloatText(
- description=kind_label,
- min=-1,
- max=1,
- step=0.1,
- value=0.0,
- disabled=True,
- )
- widgets_list.append(kind_widget)
- kinds_widget = ipw.VBox(widgets_list)
- else:
- kinds_widget = None
-
- return kinds_widget
-
- def update_kinds_widget(self):
- self.input_structure_labels = self.input_structure.get_kind_names()
- self.kinds = self.create_kinds_widget()
- self.description.value = "Define magnetization: "
- self.display_kinds()
-
- def display_kinds(self):
- if "PYTEST_CURRENT_TEST" not in os.environ and self.kinds:
- with self.kinds_widget_out:
- clear_output()
- display(self.kinds)
-
- def _update_widget(self, change):
- self.input_structure = change["new"]
- self.update_kinds_widget()
-
- def get_magnetization(self):
- """Method to generate the dictionary with the initial magnetic moments"""
- magnetization = {}
- for i in range(len(self.kinds.children)):
- magnetization[self.input_structure_labels[i]] = self.kinds.children[i].value
- return magnetization
-
- def _set_magnetization_values(self, **kwargs):
- """Update used for conftest setting all magnetization to a value"""
- self.override.value = True
- with self.hold_trait_notifications():
- if "initial_magnetic_moments" in kwargs:
- for i in range(len(self.kinds.children)):
- self.kinds.children[i].value = kwargs["initial_magnetic_moments"]
-
-
-class SmearingSettings(ipw.VBox):
- smearing_description = ipw.HTML(
- """
- The smearing type and width is set by the chosen protocol.
- Tick the box to override the default, not advised unless you've mastered smearing effects (click here for a discussion).
-
"""
- )
-
- # The default of `smearing` and `degauss` the type and width
- # must be linked to the `protocol`
- degauss_default = traitlets.Float(default_value=0.01)
- smearing_default = traitlets.Unicode(default_value="cold")
-
- def __init__(self, **kwargs):
- self.override = ipw.Checkbox(
- description="Override",
- indent=False,
- value=False,
- )
- self.smearing = ipw.Dropdown(
- options=["cold", "gaussian", "fermi-dirac", "methfessel-paxton"],
- value=self.smearing_default,
- description="Smearing type:",
- disabled=False,
- style={"description_width": "initial"},
- )
- self.degauss = ipw.FloatText(
- value=self.degauss_default,
- step=0.005,
- description="Smearing width (Ry):",
- disabled=False,
- style={"description_width": "initial"},
- )
- ipw.dlink(
- (self.override, "value"),
- (self.degauss, "disabled"),
- lambda override: not override,
- )
- ipw.dlink(
- (self.override, "value"),
- (self.smearing, "disabled"),
- lambda override: not override,
- )
- self.degauss.observe(self.set_smearing, "value")
- self.smearing.observe(self.set_smearing, "value")
- self.override.observe(self.set_smearing, "value")
-
- super().__init__(
- children=[
- self.smearing_description,
- ipw.HBox([self.override, self.smearing, self.degauss]),
- ],
- layout=ipw.Layout(justify_content="space-between"),
- **kwargs,
- )
-
- def set_smearing(self, _=None):
- self.degauss.value = (
- self.degauss.value if self.override.value else self.degauss_default
- )
- self.smearing.value = (
- self.smearing.value if self.override.value else self.smearing_default
- )
-
- def _update_settings(self, **kwargs):
- """Update the smearing and degauss values by the given keyword arguments
- This is the same as the `set_smearing` method but without the observer.
- Therefore the override checkbox is not updated and defaults to True"""
- self.override.value = True
-
- with self.hold_trait_notifications():
- if "smearing" in kwargs:
- self.smearing.value = kwargs["smearing"]
-
- if "degauss" in kwargs:
- self.degauss.value = kwargs["degauss"]
-
- def reset(self):
- with self.hold_trait_notifications():
- self.degauss.value = self.degauss_default
- self.smearing.value = self.smearing_default
- self.override.value = False
-
-
-class KpointSettings(ipw.VBox):
- kpoints_distance_description = ipw.HTML(
- """
- The k-points mesh density of the SCF calculation is set by the protocol.
- The value below represents the maximum distance between the k-points in each direction of reciprocal space.
- Tick the box to override the default, smaller is more accurate and costly.
"""
- )
-
- # The default of `kpoints_distance` must be linked to the `protocol`
- kpoints_distance_default = traitlets.Float(default_value=0.15)
-
- def __init__(self, **kwargs):
- self.override = ipw.Checkbox(
- description="Override",
- indent=False,
- value=False,
- )
- self.distance = ipw.FloatText(
- value=self.kpoints_distance_default,
- step=0.05,
- description="K-points distance (1/Å):",
- disabled=False,
- style={"description_width": "initial"},
- )
- ipw.dlink(
- (self.override, "value"),
- (self.distance, "disabled"),
- lambda override: not override,
- )
- self.distance.observe(self.set_kpoints_distance, "value")
- self.override.observe(self.set_kpoints_distance, "value")
- self.observe(self.set_kpoints_distance, "kpoints_distance_default")
-
- super().__init__(
- children=[
- self.kpoints_distance_description,
- ipw.HBox([self.override, self.distance]),
- ],
- layout=ipw.Layout(justify_content="space-between"),
- **kwargs,
- )
-
- def set_kpoints_distance(self, _=None):
- self.distance.value = (
- self.distance.value
- if self.override.value
- else self.kpoints_distance_default
- )
-
- def _update_settings(self, **kwargs):
- """Update the kpoints_distance value by the given keyword arguments.
- This is the same as the `set_kpoints_distance` method but without the observer.
- """
- self.override.value = True
- if "kpoints_distance" in kwargs:
- self.distance.value = kwargs["kpoints_distance"]
-
- def reset(self):
- with self.hold_trait_notifications():
- self.distance.value = self.kpoints_distance_default
- self.override.value = False
-
-
-class ConfigureQeAppWorkChainStep(ipw.VBox, WizardAppWidgetStep):
- confirmed = traitlets.Bool()
- previous_step_state = traitlets.UseEnum(WizardAppWidgetStep.State)
- workchain_settings = traitlets.Instance(WorkChainSettings, allow_none=True)
- pseudo_family_selector = traitlets.Instance(PseudoFamilySelector, allow_none=True)
- advanced_settings = traitlets.Instance(AdvancedSettings, allow_none=True)
- input_structure = traitlets.Instance(StructureData, allow_none=True)
-
- def __init__(self, **kwargs):
- self.workchain_settings = WorkChainSettings()
- self.workchain_settings.relax_type.observe(self._update_state, "value")
- self.workchain_settings.bands_run.observe(self._update_state, "value")
- self.workchain_settings.pdos_run.observe(self._update_state, "value")
-
- self.pseudo_family_selector = PseudoFamilySelector()
- self.advanced_settings = AdvancedSettings()
-
- ipw.dlink(
- (self.workchain_settings.workchain_protocol, "value"),
- (self.advanced_settings.kpoints, "kpoints_distance_default"),
- lambda protocol: PwBaseWorkChain.get_protocol_inputs(protocol)[
- "kpoints_distance"
- ],
- )
-
- ipw.dlink(
- (self.workchain_settings.workchain_protocol, "value"),
- (self.advanced_settings.smearing, "degauss_default"),
- lambda protocol: PwBaseWorkChain.get_protocol_inputs(protocol)["pw"][
- "parameters"
- ]["SYSTEM"]["degauss"],
- )
-
- ipw.dlink(
- (self.workchain_settings.workchain_protocol, "value"),
- (self.advanced_settings.smearing, "smearing_default"),
- lambda protocol: PwBaseWorkChain.get_protocol_inputs(protocol)["pw"][
- "parameters"
- ]["SYSTEM"]["smearing"],
- )
-
- self.tab = ipw.Tab(
- children=[
- self.workchain_settings,
- ipw.VBox(
- children=[
- self.advanced_settings,
- self.pseudo_family_selector,
- ]
- ),
- ],
- layout=ipw.Layout(min_height="250px"),
- )
-
- self.tab.set_title(0, "Workflow")
- self.tab.set_title(1, "Advanced settings")
-
- self._submission_blocker_messages = ipw.HTML()
-
- self.confirm_button = ipw.Button(
- description="Confirm",
- tooltip="Confirm the currently selected settings and go to the next step.",
- button_style="success",
- icon="check-circle",
- disabled=True,
- layout=ipw.Layout(width="auto"),
- )
-
- self.confirm_button.on_click(self.confirm)
-
- super().__init__(
- children=[
- self.tab,
- self._submission_blocker_messages,
- self.confirm_button,
- ],
- **kwargs,
- )
-
- @traitlets.observe("input_structure")
- def _update_input_structure(self, change):
- if self.input_structure is not None:
- self.advanced_settings.magnetization._update_widget(change)
-
- @traitlets.observe("previous_step_state")
- def _observe_previous_step_state(self, change):
- self._update_state()
-
- def set_input_parameters(self, parameters):
- """Set the inputs in the GUI based on a set of parameters."""
-
- with self.hold_trait_notifications():
- # Work chain settings
- self.workchain_settings.relax_type.value = parameters["relax_type"]
- self.workchain_settings.spin_type.value = parameters["spin_type"]
- self.workchain_settings.electronic_type.value = parameters[
- "electronic_type"
- ]
- self.workchain_settings.bands_run.value = parameters["run_bands"]
- self.workchain_settings.pdos_run.value = parameters["run_pdos"]
- self.workchain_settings.workchain_protocol.value = parameters["protocol"]
-
- # Advanced settings
- self.pseudo_family_selector.value = parameters["pseudo_family"]
- if parameters.get("kpoints_distance_override", None) is not None:
- self.advanced_settings.kpoints.distance.value = parameters[
- "kpoints_distance_override"
- ]
- self.advanced_settings.kpoints.override.value = True
- if parameters.get("degauss_override", None) is not None:
- self.advanced_settings.smearing.degauss.value = parameters[
- "degauss_override"
- ]
- self.advanced_settings.smearing.override.value = True
- if parameters.get("smearing_override", None) is not None:
- self.advanced_settings.smearing.smearing.value = parameters[
- "smearing_override"
- ]
- self.advanced_settings.smearing.override.value = True
-
- def _update_state(self, _=None):
- if self.previous_step_state == self.State.SUCCESS:
- self.confirm_button.disabled = False
- self._submission_blocker_messages.value = ""
- self.state = self.State.CONFIGURED
- elif self.previous_step_state == self.State.FAIL:
- self.state = self.State.FAIL
- else:
- self.confirm_button.disabled = True
- self.state = self.State.INIT
- self.set_input_parameters(DEFAULT_PARAMETERS)
-
- def confirm(self, _=None):
- self.confirm_button.disabled = False
- self.state = self.State.SUCCESS
-
- @traitlets.default("state")
- def _default_state(self):
- return self.State.INIT
-
- def reset(self):
- with self.hold_trait_notifications():
- self.set_input_parameters(DEFAULT_PARAMETERS)
-
-
-class SubmitQeAppWorkChainStep(ipw.VBox, WizardAppWidgetStep):
- """Step for submission of a bands workchain."""
-
- codes_title = ipw.HTML(
- """
-
Codes
"""
- )
- codes_help = ipw.HTML(
- """ Select the code to use for running the calculations. The codes
- on the local machine (localhost) are installed by default, but you can
- configure new ones on potentially more powerful machines by clicking on
- "Setup new code".
"""
- )
-
- # This number provides a rough estimate for how many MPI tasks are needed
- # for a given structure.
- NUM_SITES_PER_MPI_TASK_DEFAULT = 6
-
- # Warn the user if they are trying to run calculations for a large
- # structure on localhost.
- RUN_ON_LOCALHOST_NUM_SITES_WARN_THRESHOLD = 10
-
- # Put a limit on how many MPI tasks you want to run per k-pool by default
- MAX_MPI_PER_POOL = 20
-
- input_structure = traitlets.Instance(StructureData, allow_none=True)
- process = traitlets.Instance(WorkChainNode, allow_none=True)
- previous_step_state = traitlets.UseEnum(WizardAppWidgetStep.State)
- workchain_settings = traitlets.Instance(WorkChainSettings, allow_none=True)
- pseudo_family_selector = traitlets.Instance(PseudoFamilySelector, allow_none=True)
- advanced_settings = traitlets.Instance(AdvancedSettings, allow_none=True)
- _submission_blockers = traitlets.List(traitlets.Unicode())
-
- def __init__(self, qe_auto_setup=True, **kwargs):
- self.message_area = ipw.Output()
- self._submission_blocker_messages = ipw.HTML()
-
- self.pw_code = ComputationalResourcesWidget(
- description="pw.x:", default_calc_job_plugin="quantumespresso.pw"
- )
- self.dos_code = ComputationalResourcesWidget(
- description="dos.x:",
- default_calc_job_plugin="quantumespresso.dos",
- )
- self.projwfc_code = ComputationalResourcesWidget(
- description="projwfc.x:",
- default_calc_job_plugin="quantumespresso.projwfc",
- )
-
- self.resources_config = ResourceSelectionWidget()
- self.parallelization = ParallelizationSettings()
-
- self.set_selected_codes(DEFAULT_PARAMETERS)
- self.set_resource_defaults()
-
- self.pw_code.observe(self._update_state, "value")
- self.pw_code.observe(self._update_resources, "value")
- self.dos_code.observe(self._update_state, "value")
- self.projwfc_code.observe(self._update_state, "value")
-
- self.submit_button = ipw.Button(
- description="Submit",
- tooltip="Submit the calculation with the selected parameters.",
- icon="play",
- button_style="success",
- layout=ipw.Layout(width="auto", flex="1 1 auto"),
- disabled=True,
- )
-
- self.submit_button.on_click(self._on_submit_button_clicked)
-
- # The SSSP installation status widget shows the installation status of
- # the SSSP pseudo potentials and triggers the installation in case that
- # they are not yet installed. The widget will remain in a "busy" state
- # in case that the installation was already triggered elsewhere, e.g.,
- # by the start up scripts. The submission is blocked while the
- # potentials are not yet installed.
- self.sssp_installation_status = SSSPInstallWidget(auto_start=qe_auto_setup)
- self.sssp_installation_status.observe(self._update_state, ["busy", "installed"])
- self.sssp_installation_status.observe(self._toggle_install_widgets, "installed")
-
- # The QE setup widget checks whether there are codes that match specific
- # expected labels (e.g. "pw-7.2@localhost") and triggers both the
- # installation of QE into a dedicated conda environment and the setup of
- # the codes in case that they are not already configured.
- self.qe_setup_status = QESetupWidget(auto_start=qe_auto_setup)
- self.qe_setup_status.observe(self._update_state, "busy")
- self.qe_setup_status.observe(self._toggle_install_widgets, "installed")
- self.qe_setup_status.observe(self._auto_select_code, "installed")
-
- super().__init__(
- children=[
- self.codes_title,
- self.codes_help,
- self.pw_code,
- self.dos_code,
- self.projwfc_code,
- self.resources_config,
- self.parallelization,
- self.message_area,
- self.sssp_installation_status,
- self.qe_setup_status,
- self._submission_blocker_messages,
- self.submit_button,
- ]
- )
-
- @traitlets.observe("_submission_blockers")
- def _observe_submission_blockers(self, change):
- if change["new"]:
- fmt_list = "\n".join((f"{item}" for item in sorted(change["new"])))
- self._submission_blocker_messages.value = f"""
-
-
The submission is blocked, due to the following reason(s):
-
-
Resources
- """
- )
- prompt = ipw.HTML(
- """
-
- Specify the resources to use for the pw.x calculation.
-
-
Parallelization
- """
- )
- prompt = ipw.HTML(
- """
-
- Specify the number of k-points pools for the calculations.
-
+
Advanced Settings
"""
+ )
+ description = ipw.HTML("""Select the advanced settings for the pw.x code.""")
+
+ def __init__(self, **kwargs):
+ self.override = ipw.Checkbox(
+ description="Override",
+ indent=False,
+ value=False,
+ )
+ self.smearing = SmearingSettings()
+ self.kpoints = KpointSettings()
+ self.tot_charge = TotalCharge()
+ self.magnetization = MagnetizationSettings()
+ self.list_overrides = [
+ self.smearing.override,
+ self.kpoints.override,
+ self.tot_charge.override,
+ self.magnetization.override,
+ ]
+ for override in self.list_overrides:
+ ipw.dlink(
+ (self.override, "value"),
+ (override, "disabled"),
+ lambda override: not override,
+ )
+ self.override.observe(self.set_advanced_settings, "value")
+ super().__init__(
+ children=[
+ self.title,
+ ipw.HBox(
+ [
+ self.description,
+ self.override,
+ ],
+ ),
+ self.tot_charge,
+ self.magnetization,
+ self.smearing,
+ self.kpoints,
+ ],
+ layout=ipw.Layout(justify_content="space-between"),
+ **kwargs,
+ )
+
+ def set_advanced_settings(self, _=None):
+ self.smearing.reset()
+ self.kpoints.reset()
+ self.tot_charge.reset()
+ self.magnetization.reset()
+
+
+class TotalCharge(ipw.VBox):
+ """Widget to define the total charge of the simulation"""
+
+ tot_charge_default = tl.Float(default_value=0.0)
+
+ def __init__(self, **kwargs):
+ self.override = ipw.Checkbox(
+ description="Override",
+ indent=False,
+ value=False,
+ )
+ self.charge = ipw.BoundedFloatText(
+ value=0,
+ min=-3,
+ max=3,
+ step=0.01,
+ disabled=False,
+ description="Total charge:",
+ style={"description_width": "initial"},
+ )
+ ipw.dlink(
+ (self.override, "value"),
+ (self.charge, "disabled"),
+ lambda override: not override,
+ )
+ super().__init__(
+ children=[
+ ipw.HBox(
+ [
+ self.override,
+ self.charge,
+ ],
+ ),
+ ],
+ layout=ipw.Layout(justify_content="space-between"),
+ **kwargs,
+ )
+ self.charge.observe(self.set_tot_charge, "value")
+ self.override.observe(self.set_tot_charge, "value")
+
+ def set_tot_charge(self, _=None):
+ self.charge.value = (
+ self.charge.value if self.override.value else self.tot_charge_default
+ )
+
+ def _update_settings(self, **kwargs):
+ """Update the override and override_tot_charge and override_tot_charge values by the given keyword arguments
+ Therefore the override checkbox is not updated and defaults to True"""
+ self.override.value = True
+ with self.hold_trait_notifications():
+ if "tot_charge" in kwargs:
+ self.charge.value = kwargs["tot_charge"]
+
+ def reset(self):
+ with self.hold_trait_notifications():
+ self.charge.value = self.tot_charge_default
+ self.override.value = False
+
+
+class MagnetizationSettings(ipw.VBox):
+ """Widget to set the initial magnetic moments for each kind names defined in the StructureData (StructureDtaa.get_kind_names())
+ Usually these are the names of the elements in the StructureData
+ (For example 'C' , 'N' , 'Fe' . However the StructureData can have defined kinds like 'Fe1' and 'Fe2')
+
+ The widget generate a dictionary that can be used to set initial_magnetic_moments in the builder of PwBaseWorkChain
+
+ Attributes:
+ input_structure(StructureData): trait that containes the input_strucgure (confirmed structure from previous step)
+ """
+
+ input_structure = tl.Instance(orm.StructureData, allow_none=True)
+
+ def __init__(self, **kwargs):
+ self.input_structure = orm.StructureData()
+ self.input_structure_labels = []
+ self.description = ipw.HTML(
+ "Define magnetization: Input structure not confirmed"
+ )
+ self.kinds = self.create_kinds_widget()
+ self.kinds_widget_out = ipw.Output()
+ self.override = ipw.Checkbox(
+ description="Override",
+ indent=False,
+ value=False,
+ )
+ super().__init__(
+ children=[
+ ipw.HBox(
+ [
+ self.override,
+ self.description,
+ self.kinds_widget_out,
+ ],
+ ),
+ ],
+ layout=ipw.Layout(justify_content="space-between"),
+ **kwargs,
+ )
+ self.display_kinds()
+ self.override.observe(self._disable_kinds_widgets, "value")
+
+ def _disable_kinds_widgets(self, _=None):
+ for i in range(len(self.kinds.children)):
+ self.kinds.children[i].disabled = not self.override.value
+
+ def reset(self):
+ self.override.value = False
+ if hasattr(self.kinds, "children") and self.kinds.children:
+ for i in range(len(self.kinds.children)):
+ self.kinds.children[i].value = 0.0
+
+ def create_kinds_widget(self):
+ if self.input_structure_labels:
+ widgets_list = []
+ for kind_label in self.input_structure_labels:
+ kind_widget = ipw.BoundedFloatText(
+ description=kind_label,
+ min=-1,
+ max=1,
+ step=0.1,
+ value=0.0,
+ disabled=True,
+ )
+ widgets_list.append(kind_widget)
+ kinds_widget = ipw.VBox(widgets_list)
+ else:
+ kinds_widget = None
+
+ return kinds_widget
+
+ def update_kinds_widget(self):
+ self.input_structure_labels = self.input_structure.get_kind_names()
+ self.kinds = self.create_kinds_widget()
+ self.description.value = "Define magnetization: "
+ self.display_kinds()
+
+ def display_kinds(self):
+ if "PYTEST_CURRENT_TEST" not in os.environ and self.kinds:
+ with self.kinds_widget_out:
+ clear_output()
+ display(self.kinds)
+
+ def _update_widget(self, change):
+ self.input_structure = change["new"]
+ self.update_kinds_widget()
+
+ def get_magnetization(self):
+ """Method to generate the dictionary with the initial magnetic moments"""
+ magnetization = {}
+ for i in range(len(self.kinds.children)):
+ magnetization[self.input_structure_labels[i]] = self.kinds.children[i].value
+ return magnetization
+
+ def _set_magnetization_values(self, **kwargs):
+ """Update used for conftest setting all magnetization to a value"""
+ self.override.value = True
+ with self.hold_trait_notifications():
+ if "initial_magnetic_moments" in kwargs:
+ for i in range(len(self.kinds.children)):
+ self.kinds.children[i].value = kwargs["initial_magnetic_moments"]
+
+
+class SmearingSettings(ipw.VBox):
+ smearing_description = ipw.HTML(
+ """
+ The smearing type and width is set by the chosen protocol.
+ Tick the box to override the default, not advised unless you've mastered smearing effects (click here for a discussion).
+
"""
+ )
+
+ # The default of `smearing` and `degauss` the type and width
+ # must be linked to the `protocol`
+ degauss_default = tl.Float(default_value=0.01)
+ smearing_default = tl.Unicode(default_value="cold")
+
+ def __init__(self, **kwargs):
+ self.override = ipw.Checkbox(
+ description="Override",
+ indent=False,
+ value=False,
+ )
+ self.smearing = ipw.Dropdown(
+ options=["cold", "gaussian", "fermi-dirac", "methfessel-paxton"],
+ value=self.smearing_default,
+ description="Smearing type:",
+ disabled=False,
+ style={"description_width": "initial"},
+ )
+ self.degauss = ipw.FloatText(
+ value=self.degauss_default,
+ step=0.005,
+ description="Smearing width (Ry):",
+ disabled=False,
+ style={"description_width": "initial"},
+ )
+ ipw.dlink(
+ (self.override, "value"),
+ (self.degauss, "disabled"),
+ lambda override: not override,
+ )
+ ipw.dlink(
+ (self.override, "value"),
+ (self.smearing, "disabled"),
+ lambda override: not override,
+ )
+ self.degauss.observe(self.set_smearing, "value")
+ self.smearing.observe(self.set_smearing, "value")
+ self.override.observe(self.set_smearing, "value")
+
+ super().__init__(
+ children=[
+ self.smearing_description,
+ ipw.HBox([self.override, self.smearing, self.degauss]),
+ ],
+ layout=ipw.Layout(justify_content="space-between"),
+ **kwargs,
+ )
+
+ def set_smearing(self, _=None):
+ self.degauss.value = (
+ self.degauss.value if self.override.value else self.degauss_default
+ )
+ self.smearing.value = (
+ self.smearing.value if self.override.value else self.smearing_default
+ )
+
+ def _update_settings(self, **kwargs):
+ """Update the smearing and degauss values by the given keyword arguments
+ This is the same as the `set_smearing` method but without the observer.
+ Therefore the override checkbox is not updated and defaults to True"""
+ self.override.value = True
+
+ with self.hold_trait_notifications():
+ if "smearing" in kwargs:
+ self.smearing.value = kwargs["smearing"]
+
+ if "degauss" in kwargs:
+ self.degauss.value = kwargs["degauss"]
+
+ def reset(self):
+ with self.hold_trait_notifications():
+ self.degauss.value = self.degauss_default
+ self.smearing.value = self.smearing_default
+ self.override.value = False
+
+
+class KpointSettings(ipw.VBox):
+ kpoints_distance_description = ipw.HTML(
+ """
+ The k-points mesh density of the SCF calculation is set by the protocol.
+ The value below represents the maximum distance between the k-points in each direction of reciprocal space.
+ Tick the box to override the default, smaller is more accurate and costly.
"""
+ )
+
+ # The default of `kpoints_distance` must be linked to the `protocol`
+ kpoints_distance_default = tl.Float(default_value=0.15)
+
+ def __init__(self, **kwargs):
+ self.override = ipw.Checkbox(
+ description="Override",
+ indent=False,
+ value=False,
+ )
+ self.distance = ipw.FloatText(
+ value=self.kpoints_distance_default,
+ step=0.05,
+ description="K-points distance (1/Å):",
+ disabled=False,
+ style={"description_width": "initial"},
+ )
+ ipw.dlink(
+ (self.override, "value"),
+ (self.distance, "disabled"),
+ lambda override: not override,
+ )
+ self.distance.observe(self.set_kpoints_distance, "value")
+ self.override.observe(self.set_kpoints_distance, "value")
+ self.observe(self.set_kpoints_distance, "kpoints_distance_default")
+
+ super().__init__(
+ children=[
+ self.kpoints_distance_description,
+ ipw.HBox([self.override, self.distance]),
+ ],
+ layout=ipw.Layout(justify_content="space-between"),
+ **kwargs,
+ )
+
+ def set_kpoints_distance(self, _=None):
+ self.distance.value = (
+ self.distance.value
+ if self.override.value
+ else self.kpoints_distance_default
+ )
+
+ def _update_settings(self, **kwargs):
+ """Update the kpoints_distance value by the given keyword arguments.
+ This is the same as the `set_kpoints_distance` method but without the observer.
+ """
+ self.override.value = True
+ if "kpoints_distance" in kwargs:
+ self.distance.value = kwargs["kpoints_distance"]
+
+ def reset(self):
+ with self.hold_trait_notifications():
+ self.distance.value = self.kpoints_distance_default
+ self.override.value = False
diff --git a/aiidalab_qe/app/pseudos.py b/src/aiidalab_qe/app/configuration/pseudos.py
similarity index 100%
rename from aiidalab_qe/app/pseudos.py
rename to src/aiidalab_qe/app/configuration/pseudos.py
diff --git a/src/aiidalab_qe/app/configuration/workflow.py b/src/aiidalab_qe/app/configuration/workflow.py
new file mode 100644
index 00000000..56c04133
--- /dev/null
+++ b/src/aiidalab_qe/app/configuration/workflow.py
@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+"""Widgets for the submission of bands work chains.
+
+Authors: AiiDAlab team
+"""
+import ipywidgets as ipw
+
+from aiidalab_qe.app.parameters import DEFAULT_PARAMETERS
+
+
+class WorkChainSettings(ipw.VBox):
+ structure_title = ipw.HTML(
+ """
+
Structure
"""
+ )
+ structure_help = ipw.HTML(
+ """
+ You have three options:
+ (1) Structure as is: perform a self consistent calculation using the structure provided as input.
+ (2) Atomic positions: perform a full relaxation of the internal atomic coordinates.
+ (3) Full geometry: perform a full relaxation for both the internal atomic coordinates and the cell vectors.
"""
+ )
+ materials_help = ipw.HTML(
+ """
+ Below you can indicate both if the material should be treated as an insulator
+ or a metal (if in doubt, choose "Metal"),
+ and if it should be studied with magnetization/spin polarization,
+ switch magnetism On or Off (On is at least twice more costly).
+
"""
+ )
+
+ properties_title = ipw.HTML(
+ """
+
Properties
"""
+ )
+ properties_help = ipw.HTML(
+ """
+ The band structure workflow will
+ automatically detect the default path in reciprocal space using the
+
+ SeeK-path tool.
+
Protocol
"""
+ )
+ protocol_help = ipw.HTML(
+ """
+ The "moderate" protocol represents a trade-off between
+ accuracy and speed. Choose the "fast" protocol for a faster calculation
+ with less precision and the "precise" protocol to aim at best accuracy (at the price of longer/costlier calculations).
"""
+ )
+
+ def __init__(self, **kwargs):
+ # RelaxType: degrees of freedom in geometry optimization
+ self.relax_type = ipw.ToggleButtons(
+ options=[
+ ("Structure as is", "none"),
+ ("Atomic positions", "positions"),
+ ("Full geometry", "positions_cell"),
+ ],
+ value="positions_cell",
+ )
+
+ # SpinType: magnetic properties of material
+ self.spin_type = ipw.ToggleButtons(
+ options=[("Off", "none"), ("On", "collinear")],
+ value=DEFAULT_PARAMETERS["spin_type"],
+ style={"description_width": "initial"},
+ )
+
+ # ElectronicType: electronic properties of material
+ self.electronic_type = ipw.ToggleButtons(
+ options=[("Metal", "metal"), ("Insulator", "insulator")],
+ value=DEFAULT_PARAMETERS["electronic_type"],
+ style={"description_width": "initial"},
+ )
+
+ # Checkbox to see if the band structure should be calculated
+ self.bands_run = ipw.Checkbox(
+ description="",
+ indent=False,
+ value=True,
+ layout=ipw.Layout(max_width="10%"),
+ )
+
+ # Checkbox to see if the PDOS should be calculated
+ self.pdos_run = ipw.Checkbox(
+ description="",
+ indent=False,
+ value=True,
+ layout=ipw.Layout(max_width="10%"),
+ )
+
+ # Work chain protocol
+ self.workchain_protocol = ipw.ToggleButtons(
+ options=["fast", "moderate", "precise"],
+ value="moderate",
+ )
+ super().__init__(
+ children=[
+ self.structure_title,
+ self.structure_help,
+ self.relax_type,
+ self.materials_help,
+ ipw.HBox(
+ children=[
+ ipw.Label(
+ "Electronic Type:",
+ layout=ipw.Layout(
+ justify_content="flex-start", width="120px"
+ ),
+ ),
+ self.electronic_type,
+ ]
+ ),
+ ipw.HBox(
+ children=[
+ ipw.Label(
+ "Magnetism:",
+ layout=ipw.Layout(
+ justify_content="flex-start", width="120px"
+ ),
+ ),
+ self.spin_type,
+ ]
+ ),
+ self.properties_title,
+ ipw.HTML("Select which properties to calculate:"),
+ ipw.HBox(children=[ipw.HTML("Band structure"), self.bands_run]),
+ ipw.HBox(
+ children=[
+ ipw.HTML("Projected density of states"),
+ self.pdos_run,
+ ]
+ ),
+ self.properties_help,
+ self.protocol_title,
+ ipw.HTML("Select the protocol:", layout=ipw.Layout(flex="1 1 auto")),
+ self.workchain_protocol,
+ self.protocol_help,
+ ],
+ **kwargs,
+ )
+
+ def _update_settings(self, **kwargs):
+ """Update the settings based on the given dict."""
+ for key in [
+ "relax_type",
+ "spin_type",
+ "electronic_type",
+ "bands_run",
+ "pdos_run",
+ "workchain_protocol",
+ ]:
+ if key in kwargs:
+ getattr(self, key).value = kwargs[key]
diff --git a/aiidalab_qe/app/parameters/__init__.py b/src/aiidalab_qe/app/parameters/__init__.py
similarity index 100%
rename from aiidalab_qe/app/parameters/__init__.py
rename to src/aiidalab_qe/app/parameters/__init__.py
diff --git a/aiidalab_qe/app/parameters/qeapp.yaml b/src/aiidalab_qe/app/parameters/qeapp.yaml
similarity index 100%
rename from aiidalab_qe/app/parameters/qeapp.yaml
rename to src/aiidalab_qe/app/parameters/qeapp.yaml
diff --git a/src/aiidalab_qe/app/result/__init__.py b/src/aiidalab_qe/app/result/__init__.py
new file mode 100644
index 00000000..09d4597a
--- /dev/null
+++ b/src/aiidalab_qe/app/result/__init__.py
@@ -0,0 +1,75 @@
+import ipywidgets as ipw
+import traitlets as tl
+from aiida import orm
+from aiida.engine import ProcessState
+from aiidalab_widgets_base import (
+ AiidaNodeViewWidget,
+ ProcessMonitor,
+ ProcessNodesTreeWidget,
+ WizardAppWidgetStep,
+)
+
+# trigger registration of the viewer widget:
+from .workchain_viewer import WorkChainViewer # noqa: F401
+
+
+class ViewQeAppWorkChainStatusAndResultsStep(ipw.VBox, WizardAppWidgetStep):
+ process = tl.Unicode(allow_none=True)
+
+ def __init__(self, **kwargs):
+ self.process_tree = ProcessNodesTreeWidget()
+ ipw.dlink(
+ (self, "process"),
+ (self.process_tree, "value"),
+ )
+
+ self.node_view = AiidaNodeViewWidget(layout={"width": "auto", "height": "auto"})
+ ipw.dlink(
+ (self.process_tree, "selected_nodes"),
+ (self.node_view, "node"),
+ transform=lambda nodes: nodes[0] if nodes else None,
+ )
+ self.process_status = ipw.VBox(children=[self.process_tree, self.node_view])
+
+ # Setup process monitor
+ self.process_monitor = ProcessMonitor(
+ timeout=0.2,
+ callbacks=[
+ self.process_tree.update,
+ self._update_state,
+ ],
+ )
+ ipw.dlink((self, "process"), (self.process_monitor, "value"))
+
+ super().__init__([self.process_status], **kwargs)
+
+ def can_reset(self):
+ "Do not allow reset while process is running."
+ return self.state is not self.State.ACTIVE
+
+ def reset(self):
+ self.process = None
+
+ def _update_state(self):
+ if self.process is None:
+ self.state = self.State.INIT
+ else:
+ process = orm.load_node(self.process)
+ process_state = process.process_state
+ if process_state in (
+ ProcessState.CREATED,
+ ProcessState.RUNNING,
+ ProcessState.WAITING,
+ ):
+ self.state = self.State.ACTIVE
+ elif (
+ process_state in (ProcessState.EXCEPTED, ProcessState.KILLED)
+ or process.is_failed
+ ):
+ self.state = self.State.FAIL
+ elif process.is_finished_ok:
+ self.state = self.State.SUCCESS
+
+ @tl.observe("process")
+ def _observe_process(self, change):
+ self._update_state()
diff --git a/src/aiidalab_qe/app/result/electronic_structure.py b/src/aiidalab_qe/app/result/electronic_structure.py
new file mode 100644
index 00000000..c3cc846f
--- /dev/null
+++ b/src/aiidalab_qe/app/result/electronic_structure.py
@@ -0,0 +1,179 @@
+import json
+import random
+
+from aiida import orm
+from monty.json import jsanitize
+
+
+def export_data(work_chain_node, group_dos_by="atom"):
+ dos = export_pdos_data(work_chain_node, group_dos_by=group_dos_by)
+ fermi_energy = dos["fermi_energy"] if dos else None
+
+ bands = export_bands_data(work_chain_node, fermi_energy)
+
+ return dict(
+ bands=bands,
+ dos=dos,
+ )
+
+
+def export_pdos_data(work_chain_node, group_dos_by="atom"):
+ if "dos" in work_chain_node.outputs:
+ _, energy_dos, _ = work_chain_node.outputs.dos.get_x()
+ tdos_values = {f"{n}": v for n, v, _ in work_chain_node.outputs.dos.get_y()}
+
+ dos = []
+
+ if "projections" in work_chain_node.outputs:
+ # The total dos parsed
+ tdos = {
+ "label": "Total DOS",
+ "x": energy_dos.tolist(),
+ "y": tdos_values.get("dos").tolist(),
+ "borderColor": "#8A8A8A", # dark gray
+ "backgroundColor": "#999999", # light gray
+ "backgroundAlpha": "40%",
+ "lineStyle": "solid",
+ }
+ dos.append(tdos)
+
+ dos += _projections_curated(
+ work_chain_node.outputs.projections,
+ group_dos_by=group_dos_by,
+ spin_type="none",
+ )
+
+ else:
+ # The total dos parsed
+ tdos_up = {
+ "label": "Total DOS (↑)",
+ "x": energy_dos.tolist(),
+ "y": tdos_values.get("dos_spin_up").tolist(),
+ "borderColor": "#8A8A8A", # dark gray
+ "backgroundColor": "#999999", # light gray
+ "backgroundAlpha": "40%",
+ "lineStyle": "solid",
+ }
+ tdos_down = {
+ "label": "Total DOS (↓)",
+ "x": energy_dos.tolist(),
+ "y": (-tdos_values.get("dos_spin_down")).tolist(), # minus
+ "borderColor": "#8A8A8A", # dark gray
+ "backgroundColor": "#999999", # light gray
+ "backgroundAlpha": "40%",
+ "lineStyle": "dash",
+ }
+ dos += [tdos_up, tdos_down]
+
+ # spin-up (↑)
+ dos += _projections_curated(
+ work_chain_node.outputs.projections_up,
+ group_dos_by=group_dos_by,
+ spin_type="up",
+ )
+
+ # spin-dn (↓)
+ dos += _projections_curated(
+ work_chain_node.outputs.projections_down,
+ group_dos_by=group_dos_by,
+ spin_type="down",
+ line_style="dash",
+ )
+
+ data_dict = {
+ "fermi_energy": work_chain_node.outputs.nscf_parameters["fermi_energy"],
+ "dos": dos,
+ }
+
+ return json.loads(json.dumps(data_dict))
+
+ else:
+ return None
+
+
+def export_bands_data(work_chain_node, fermi_energy=None):
+ if "band_structure" in work_chain_node.outputs:
+ data = json.loads(
+ work_chain_node.outputs.band_structure._exportcontent(
+ "json", comments=False
+ )[0]
+ )
+ # The fermi energy from band calculation is not robust.
+ data["fermi_level"] = (
+ fermi_energy or work_chain_node.outputs.band_parameters["fermi_energy"]
+ )
+ return [
+ jsanitize(data),
+ ]
+ else:
+ return None
+
+
+def _projections_curated(
+ projections: orm.ProjectionData,
+ group_dos_by="atom",
+ spin_type="none",
+ line_style="solid",
+):
+ """Collect the data from ProjectionData and parse it as dos list which can be
+ understand by bandsplot widget. `group_dos_by` is for which tag to be grouped, by atom or by orbital name.
+ The spin_type is used to invert all the y values of pdos to be shown as spin down pdos and to set label.
+ """
+ _pdos = {}
+
+ for orbital, pdos, energy in projections.get_pdos():
+ orbital_data = orbital.get_orbital_dict()
+ kind_name = orbital_data["kind_name"]
+ atom_position = [round(i, 2) for i in orbital_data["position"]]
+ orbital_name = orbital.get_name_from_quantum_numbers(
+ orbital_data["angular_momentum"], orbital_data["magnetic_number"]
+ ).lower()
+
+ if group_dos_by == "atom":
+ dos_group_name = atom_position
+ elif group_dos_by == "angular":
+ # by orbital label
+ dos_group_name = orbital_name[0]
+ elif group_dos_by == "angular_and_magnetic":
+ # by orbital label
+ dos_group_name = orbital_name
+ else:
+ raise Exception(f"Unknow dos type: {group_dos_by}!")
+
+ key = f"{kind_name}-{dos_group_name}"
+ if key in _pdos:
+ _pdos[key][1] += pdos
+ else:
+ _pdos[key] = [energy, pdos]
+
+ dos = []
+ for label, (energy, pdos) in _pdos.items():
+ if spin_type == "down":
+ # invert y-axis
+ pdos = -pdos
+ label = f"{label} (↓)"
+
+ if spin_type == "up":
+ label = f"{label} (↑)"
+
+ orbital_pdos = {
+ "label": label,
+ "x": energy.tolist(),
+ "y": pdos.tolist(),
+ "borderColor": cmap(label),
+ "lineStyle": line_style,
+ }
+ dos.append(orbital_pdos)
+
+ return dos
+
+
+def cmap(label: str) -> str:
+ """Return RGB string of color for given pseudo info
+ Hardcoded at the momment.
+ """
+ # if a unknow type generate random color based on ascii sum
+ ascn = sum([ord(c) for c in label])
+ random.seed(ascn)
+
+ return "#%06x" % random.randint(0, 0xFFFFFF)
diff --git a/aiidalab_qe/app/report.py b/src/aiidalab_qe/app/result/report.py
similarity index 100%
rename from aiidalab_qe/app/report.py
rename to src/aiidalab_qe/app/result/report.py
diff --git a/src/aiidalab_qe/app/result/summary_viewer.py b/src/aiidalab_qe/app/result/summary_viewer.py
new file mode 100644
index 00000000..abc7739a
--- /dev/null
+++ b/src/aiidalab_qe/app/result/summary_viewer.py
@@ -0,0 +1,14 @@
+import ipywidgets as ipw
+
+from .report import generate_report_html
+
+
+class SummaryView(ipw.VBox):
+ def __init__(self, wc_node, **kwargs):
+ report_html = generate_report_html(wc_node)
+
+ self.summary_view = ipw.HTML(report_html)
+ super().__init__(
+ children=[self.summary_view],
+ **kwargs,
+ )
diff --git a/aiidalab_qe/app/node_view.py b/src/aiidalab_qe/app/result/workchain_viewer.py
similarity index 56%
rename from aiidalab_qe/app/node_view.py
rename to src/aiidalab_qe/app/result/workchain_viewer.py
index 00e2a654..73d6d8f8 100644
--- a/aiidalab_qe/app/node_view.py
+++ b/src/aiidalab_qe/app/result/workchain_viewer.py
@@ -1,302 +1,187 @@
-"""Results view widgets (MOVE TO OTHER MODULE!)
-
-Authors: AiiDAlab team
-"""
-
-import json
-import random
import shutil
-import typing
+import typing as t
from importlib import resources
from pathlib import Path
from tempfile import TemporaryDirectory
import ipywidgets as ipw
-import nglview
-import traitlets
+import traitlets as tl
+from aiida import orm
from aiida.cmdline.utils.common import get_workchain_report
from aiida.common import LinkType
-from aiida.orm import CalcJobNode, Node, ProjectionData, WorkChainNode
from aiidalab_widgets_base import ProcessMonitor, register_viewer_widget
from aiidalab_widgets_base.viewers import StructureDataViewer
-from ase import Atoms
from filelock import FileLock, Timeout
from IPython.display import HTML, display
from jinja2 import Environment
-from monty.json import jsanitize
-from traitlets import Instance, Int, List, Unicode, Union, default, observe, validate
from widget_bandsplot import BandsPlotWidget
from aiidalab_qe.app import static
-from aiidalab_qe.app.report import generate_report_html
+from .electronic_structure import export_data
+from .summary_viewer import SummaryView
-class MinimalStructureViewer(ipw.VBox):
- structure = Union([Instance(Atoms), Instance(Node)], allow_none=True)
- _displayed_structure = Instance(Atoms, allow_none=True, read_only=True)
- background = Unicode()
- supercell = List(Int())
+@register_viewer_widget("process.workflow.workchain.WorkChainNode.")
+class WorkChainViewer(ipw.VBox):
+ _results_shown = tl.Set()
- def __init__(self, structure, *args, **kwargs):
- self._viewer = nglview.NGLWidget()
- self._viewer.camera = "orthographic"
- self._viewer.stage.set_parameters(mouse_preset="pymol")
- ipw.link((self, "background"), (self._viewer, "background"))
+ def __init__(self, node, **kwargs):
+ if node.process_label != "QeAppWorkChain":
+ super().__init__()
+ return
- self.structure = structure
+ self.node = node
- super().__init__(
- children=[
- self._viewer,
- ],
- *args,
- **kwargs,
+ self.title = ipw.HTML(
+ f"""
+
+ QE App Workflow (pk: {self.node.pk}) —
+ {self.node.inputs.structure.get_formula()}
+
+ """
)
+ self.workflows_summary = SummaryView(self.node)
- @default("background")
- def _default_background(self):
- return "#FFFFFF"
-
- @default("supercell")
- def _default_supercell(self):
- return [1, 1, 1]
-
- @validate("structure")
- def _valid_structure(self, change): # pylint: disable=no-self-use
- """Update structure."""
- structure = change["value"]
-
- if structure is None:
- return None # if no structure provided, the rest of the code can be skipped
-
- if isinstance(structure, Atoms):
- return structure
- if isinstance(structure, Node):
- return structure.get_ase()
- raise ValueError(
- "Unsupported type {}, structure must be one of the following types: "
- "ASE Atoms object, AiiDA CifData or StructureData."
+ self.summary_tab = ipw.VBox(children=[self.workflows_summary])
+ self.structure_tab = ipw.VBox(
+ [ipw.Label("Structure not available.")],
+ layout=ipw.Layout(min_height="380px"),
)
-
- @observe("structure")
- def _update_displayed_structure(self, change):
- """Update displayed_structure trait after the structure trait has been modified."""
- # Remove the current structure(s) from the viewer.
- if change["new"] is not None:
- self.set_trait("_displayed_structure", change["new"].repeat(self.supercell))
- else:
- self.set_trait("_displayed_structure", None)
-
- @observe("_displayed_structure")
- def _update_structure_viewer(self, change):
- """Update the view if displayed_structure trait was modified."""
- with self.hold_trait_notifications():
- for (
- comp_id
- ) in self._viewer._ngl_component_ids: # pylint: disable=protected-access
- self._viewer.remove_component(comp_id)
- self.selection = list()
- if change["new"] is not None:
- self._viewer.add_component(nglview.ASEStructure(change["new"]))
- self._viewer.clear()
- self._viewer.stage.set_parameters(clipDist=0)
- self._viewer.add_representation("unitcell", diffuse="#df0587")
- self._viewer.add_representation("ball+stick", aspectRatio=3.5)
-
-
-def export_bands_data(work_chain_node, fermi_energy=None):
- if "band_structure" in work_chain_node.outputs:
- data = json.loads(
- work_chain_node.outputs.band_structure._exportcontent(
- "json", comments=False
- )[0]
+ self.bands_tab = ipw.VBox(
+ [ipw.Label("Electronic Structure not available.")],
+ layout=ipw.Layout(min_height="380px"),
)
- # The fermi energy from band calculation is not robust.
- data["fermi_level"] = (
- fermi_energy or work_chain_node.outputs.band_parameters["fermi_energy"]
+ self.result_tabs = ipw.Tab(
+ children=[self.summary_tab, self.structure_tab, self.bands_tab]
)
- return [
- jsanitize(data),
- ]
- else:
- return None
-
-
-def cmap(label: str) -> str:
- """Return RGB string of color for given pseudo info
- Hardcoded at the momment.
- """
- # if a unknow type generate random color based on ascii sum
- ascn = sum([ord(c) for c in label])
- random.seed(ascn)
-
- return "#%06x" % random.randint(0, 0xFFFFFF)
-
-
-def _projections_curated(
- projections: ProjectionData,
- group_dos_by="atom",
- spin_type="none",
- line_style="solid",
-):
- """Collect the data from ProjectionData and parse it as dos list which can be
- understand by bandsplot widget. `group_dos_by` is for which tag to be grouped, by atom or by orbital name.
- The spin_type is used to invert all the y values of pdos to be shown as spin down pdos and to set label.
- """
- _pdos = {}
-
- for orbital, pdos, energy in projections.get_pdos():
- orbital_data = orbital.get_orbital_dict()
- kind_name = orbital_data["kind_name"]
- atom_position = [round(i, 2) for i in orbital_data["position"]]
- orbital_name = orbital.get_name_from_quantum_numbers(
- orbital_data["angular_momentum"], orbital_data["magnetic_number"]
- ).lower()
-
- if group_dos_by == "atom":
- dos_group_name = atom_position
- elif group_dos_by == "angular":
- # by orbital label
- dos_group_name = orbital_name[0]
- elif group_dos_by == "angular_and_magnetic":
- # by orbital label
- dos_group_name = orbital_name
- else:
- raise Exception(f"Unknow dos type: {group_dos_by}!")
-
- key = f"{kind_name}-{dos_group_name}"
- if key in _pdos:
- _pdos[key][1] += pdos
- else:
- _pdos[key] = [energy, pdos]
-
- dos = []
- for label, (energy, pdos) in _pdos.items():
- if spin_type == "down":
- # invert y-axis
- pdos = -pdos
- label = f"{label} (↓)"
-
- if spin_type == "up":
- label = f"{label} (↑)"
-
- orbital_pdos = {
- "label": label,
- "x": energy.tolist(),
- "y": pdos.tolist(),
- "borderColor": cmap(label),
- "lineStyle": line_style,
- }
- dos.append(orbital_pdos)
-
- return dos
-
-
-def export_pdos_data(work_chain_node, group_dos_by="atom"):
- if "dos" in work_chain_node.outputs:
- _, energy_dos, _ = work_chain_node.outputs.dos.get_x()
- tdos_values = {f"{n}": v for n, v, _ in work_chain_node.outputs.dos.get_y()}
-
- dos = []
-
- if "projections" in work_chain_node.outputs:
- # The total dos parsed
- tdos = {
- "label": "Total DOS",
- "x": energy_dos.tolist(),
- "y": tdos_values.get("dos").tolist(),
- "borderColor": "#8A8A8A", # dark gray
- "backgroundColor": "#999999", # light gray
- "backgroundAlpha": "40%",
- "lineStyle": "solid",
- }
- dos.append(tdos)
-
- dos += _projections_curated(
- work_chain_node.outputs.projections,
- group_dos_by=group_dos_by,
- spin_type="none",
- )
- else:
- # The total dos parsed
- tdos_up = {
- "label": "Total DOS (↑)",
- "x": energy_dos.tolist(),
- "y": tdos_values.get("dos_spin_up").tolist(),
- "borderColor": "#8A8A8A", # dark gray
- "backgroundColor": "#999999", # light gray
- "backgroundAlpha": "40%",
- "lineStyle": "solid",
- }
- tdos_down = {
- "label": "Total DOS (↓)",
- "x": energy_dos.tolist(),
- "y": (-tdos_values.get("dos_spin_down")).tolist(), # minus
- "borderColor": "#8A8A8A", # dark gray
- "backgroundColor": "#999999", # light gray
- "backgroundAlpha": "40%",
- "lineStyle": "dash",
- }
- dos += [tdos_up, tdos_down]
-
- # spin-up (↑)
- dos += _projections_curated(
- work_chain_node.outputs.projections_up,
- group_dos_by=group_dos_by,
- spin_type="up",
- )
+ self.result_tabs.set_title(0, "Workflow Summary")
+ self.result_tabs.set_title(1, "Final Geometry (n/a)")
+ self.result_tabs.set_title(2, "Electronic Structure (n/a)")
- # spin-dn (↓)
- dos += _projections_curated(
- work_chain_node.outputs.projections_down,
- group_dos_by=group_dos_by,
- spin_type="down",
- line_style="dash",
- )
+ # An ugly fix to the structure appearance problem
+ # https://github.com/aiidalab/aiidalab-qe/issues/69
+ def on_selected_index_change(change):
+ index = change["new"]
+ # Accessing the viewer only if the corresponding tab is present.
+ if self.result_tabs._titles[str(index)] == "Final Geometry":
+ self._structure_view._viewer.handle_resize()
- data_dict = {
- "fermi_energy": work_chain_node.outputs.nscf_parameters["fermi_energy"],
- "dos": dos,
- }
+ def toggle_camera():
+ """Toggle camera between perspective and orthographic."""
+ self._structure_view._viewer.camera = (
+ "perspective"
+ if self._structure_view._viewer.camera == "orthographic"
+ else "orthographic"
+ )
- return json.loads(json.dumps(data_dict))
+ toggle_camera()
+ toggle_camera()
- else:
- return None
+ self.result_tabs.observe(on_selected_index_change, "selected_index")
+ self._update_view()
+ super().__init__(
+ children=[self.title, self.result_tabs],
+ **kwargs,
+ )
+ self._process_monitor = ProcessMonitor(
+ process=self.node,
+ callbacks=[
+ self._update_view,
+ ],
+ )
-def export_data(work_chain_node, group_dos_by="atom"):
- dos = export_pdos_data(work_chain_node, group_dos_by=group_dos_by)
- fermi_energy = dos["fermi_energy"] if dos else None
+ def _update_view(self):
+ with self.hold_trait_notifications():
+ if self.node.is_finished:
+ self._show_workflow_output()
+ if (
+ "structure" not in self._results_shown
+ and "structure" in self.node.outputs
+ ):
+ self._show_structure()
+ self._results_shown.add("structure")
- bands = export_bands_data(work_chain_node, fermi_energy)
+ if "electronic_structure" not in self._results_shown and (
+ "band_structure" in self.node.outputs or "dos" in self.node.outputs
+ ):
+ self._show_electronic_structure()
+ self._results_shown.add("electronic_structure")
- return dict(
- bands=bands,
- dos=dos,
- )
+ def _show_structure(self):
+ self._structure_view = StructureDataViewer(
+ structure=self.node.outputs.structure
+ )
+ self.result_tabs.children[1].children = [self._structure_view]
+ self.result_tabs.set_title(1, "Final Geometry")
+ def _show_electronic_structure(self):
+ group_dos_by = ipw.ToggleButtons(
+ options=[
+ ("Atom", "atom"),
+ ("Orbital", "angular"),
+ ],
+ value="atom",
+ )
+ settings = ipw.VBox(
+ children=[
+ ipw.HBox(
+ children=[
+ ipw.Label(
+ "DOS grouped by:",
+ layout=ipw.Layout(
+ justify_content="flex-start", width="120px"
+ ),
+ ),
+ group_dos_by,
+ ]
+ ),
+ ],
+ layout={"margin": "0 0 30px 30px"},
+ )
+ #
+ data = export_data(self.node, group_dos_by=group_dos_by.value)
+ bands_data = data.get("bands", None)
+ dos_data = data.get("dos", None)
+ _bands_plot_view = BandsPlotWidget(
+ bands=bands_data,
+ dos=dos_data,
+ )
-class VBoxWithCaption(ipw.VBox):
- def __init__(self, caption, body, *args, **kwargs):
- super().__init__(children=[ipw.HTML(caption), body], *args, **kwargs)
+ def response(change):
+ data = export_data(self.node, group_dos_by=group_dos_by.value)
+ bands_data = data.get("bands", None)
+ dos_data = data.get("dos", None)
+ _bands_plot_view = BandsPlotWidget(
+ bands=bands_data,
+ dos=dos_data,
+ )
+ self.result_tabs.children[2].children = [
+ settings,
+ _bands_plot_view,
+ ]
+ group_dos_by.observe(response, names="value")
+ # update the electronic structure tab
+ self.result_tabs.children[2].children = [
+ settings,
+ _bands_plot_view,
+ ]
+ self.result_tabs.set_title(2, "Electronic Structure")
-class SummaryView(ipw.VBox):
- def __init__(self, wc_node, **kwargs):
- report_html = generate_report_html(wc_node)
+ def _show_workflow_output(self):
+ self.workflows_output = WorkChainOutputs(self.node)
- self.summary_view = ipw.HTML(report_html)
- super().__init__(
- children=[self.summary_view],
- **kwargs,
- )
+ self.result_tabs.children[0].children = [
+ self.workflows_summary,
+ self.workflows_output,
+ ]
class WorkChainOutputs(ipw.VBox):
- _busy = traitlets.Bool(read_only=True)
+ _busy = tl.Bool(read_only=True)
def __init__(self, node, export_dir=None, **kwargs):
self.export_dir = Path.cwd().joinpath("exports")
@@ -349,11 +234,11 @@ def __init__(self, node, export_dir=None, **kwargs):
**kwargs,
)
- @traitlets.default("_busy")
+ @tl.default("_busy")
def _default_busy(self):
return False
- @traitlets.observe("_busy")
+ @tl.observe("_busy")
def _observe_busy(self, change):
self._download_button_container.children = [
self._create_archive_indicator
@@ -409,7 +294,7 @@ def _download_archive(self, _):
)
@classmethod
- def _prepare_calcjob_io(cls, node: WorkChainNode, root_folder: Path):
+ def _prepare_calcjob_io(cls, node: orm.WorkChainNode, root_folder: Path):
"""Prepare the calculation job input and output files.
:param node: QeAppWorkChain node.
@@ -440,7 +325,7 @@ def _prepare_calcjob_io(cls, node: WorkChainNode, root_folder: Path):
counter += 1
@staticmethod
- def _get_final_calcjob(node: WorkChainNode) -> typing.Union[None, CalcJobNode]:
+ def _get_final_calcjob(node: orm.WorkChainNode) -> t.Union[None, orm.CalcJobNode]:
"""Get the final calculation job node called by a work chain node.
:param node: Work chain node.
@@ -449,7 +334,7 @@ def _get_final_calcjob(node: WorkChainNode) -> typing.Union[None, CalcJobNode]:
final_calcjob = [
process
for process in node.called_descendants
- if isinstance(process, CalcJobNode) and process.is_finished
+ if isinstance(process, orm.CalcJobNode) and process.is_finished
][-1]
except IndexError:
final_calcjob = None
@@ -457,7 +342,7 @@ def _get_final_calcjob(node: WorkChainNode) -> typing.Union[None, CalcJobNode]:
return final_calcjob
@staticmethod
- def _write_calcjob_io(calcjob: CalcJobNode, folder: Path) -> None:
+ def _write_calcjob_io(calcjob: orm.CalcJobNode, folder: Path) -> None:
"""Write the ``calcjob`` in and output files to ``folder``.
:param calcjob: calculation job node for which to write the IO files.
@@ -485,161 +370,3 @@ def _write_calcjob_io(calcjob: CalcJobNode, folder: Path) -> None:
out_filepath = folder / filename
with out_filepath.open("w") as handle:
handle.write(retrieved.get_object_content(filename))
-
-
-@register_viewer_widget("process.workflow.workchain.WorkChainNode.")
-class WorkChainViewer(ipw.VBox):
- _results_shown = traitlets.Set()
-
- def __init__(self, node, **kwargs):
- if node.process_label != "QeAppWorkChain":
- super().__init__()
- return
-
- self.node = node
-
- self.title = ipw.HTML(
- f"""
-
- QE App Workflow (pk: {self.node.pk}) —
- {self.node.inputs.structure.get_formula()}
-
- """
- )
- self.workflows_summary = SummaryView(self.node)
-
- self.summary_tab = ipw.VBox(children=[self.workflows_summary])
- self.structure_tab = ipw.VBox(
- [ipw.Label("Structure not available.")],
- layout=ipw.Layout(min_height="380px"),
- )
- self.bands_tab = ipw.VBox(
- [ipw.Label("Electronic Structure not available.")],
- layout=ipw.Layout(min_height="380px"),
- )
- self.result_tabs = ipw.Tab(
- children=[self.summary_tab, self.structure_tab, self.bands_tab]
- )
-
- self.result_tabs.set_title(0, "Workflow Summary")
- self.result_tabs.set_title(1, "Final Geometry (n/a)")
- self.result_tabs.set_title(2, "Electronic Structure (n/a)")
-
- # An ugly fix to the structure appearance problem
- # https://github.com/aiidalab/aiidalab-qe/issues/69
- def on_selected_index_change(change):
- index = change["new"]
- # Accessing the viewer only if the corresponding tab is present.
- if self.result_tabs._titles[str(index)] == "Final Geometry":
- self._structure_view._viewer.handle_resize()
-
- def toggle_camera():
- """Toggle camera between perspective and orthographic."""
- self._structure_view._viewer.camera = (
- "perspective"
- if self._structure_view._viewer.camera == "orthographic"
- else "orthographic"
- )
-
- toggle_camera()
- toggle_camera()
-
- self.result_tabs.observe(on_selected_index_change, "selected_index")
- self._update_view()
-
- super().__init__(
- children=[self.title, self.result_tabs],
- **kwargs,
- )
- self._process_monitor = ProcessMonitor(
- process=self.node,
- callbacks=[
- self._update_view,
- ],
- )
-
- def _update_view(self):
- with self.hold_trait_notifications():
- if self.node.is_finished:
- self._show_workflow_output()
- if (
- "structure" not in self._results_shown
- and "structure" in self.node.outputs
- ):
- self._show_structure()
- self._results_shown.add("structure")
-
- if "electronic_structure" not in self._results_shown and (
- "band_structure" in self.node.outputs or "dos" in self.node.outputs
- ):
- self._show_electronic_structure()
- self._results_shown.add("electronic_structure")
-
- def _show_structure(self):
- self._structure_view = StructureDataViewer(
- structure=self.node.outputs.structure
- )
- self.result_tabs.children[1].children = [self._structure_view]
- self.result_tabs.set_title(1, "Final Geometry")
-
- def _show_electronic_structure(self):
- group_dos_by = ipw.ToggleButtons(
- options=[
- ("Atom", "atom"),
- ("Orbital", "angular"),
- ],
- value="atom",
- )
- settings = ipw.VBox(
- children=[
- ipw.HBox(
- children=[
- ipw.Label(
- "DOS grouped by:",
- layout=ipw.Layout(
- justify_content="flex-start", width="120px"
- ),
- ),
- group_dos_by,
- ]
- ),
- ],
- layout={"margin": "0 0 30px 30px"},
- )
- #
- data = export_data(self.node, group_dos_by=group_dos_by.value)
- bands_data = data.get("bands", None)
- dos_data = data.get("dos", None)
- _bands_plot_view = BandsPlotWidget(
- bands=bands_data,
- dos=dos_data,
- )
-
- def response(change):
- data = export_data(self.node, group_dos_by=group_dos_by.value)
- bands_data = data.get("bands", None)
- dos_data = data.get("dos", None)
- _bands_plot_view = BandsPlotWidget(
- bands=bands_data,
- dos=dos_data,
- )
- self.result_tabs.children[2].children = [
- settings,
- _bands_plot_view,
- ]
-
- group_dos_by.observe(response, names="value")
- # update the electronic structure tab
- self.result_tabs.children[2].children = [
- settings,
- _bands_plot_view,
- ]
- self.result_tabs.set_title(2, "Electronic Structure")
-
- def _show_workflow_output(self):
- self.workflows_output = WorkChainOutputs(self.node)
-
- self.result_tabs.children[0].children = [
- self.workflows_summary,
- self.workflows_output,
- ]
diff --git a/aiidalab_qe/app/static/__init__.py b/src/aiidalab_qe/app/static/__init__.py
similarity index 100%
rename from aiidalab_qe/app/static/__init__.py
rename to src/aiidalab_qe/app/static/__init__.py
diff --git a/aiidalab_qe/app/static/style.css b/src/aiidalab_qe/app/static/style.css
similarity index 100%
rename from aiidalab_qe/app/static/style.css
rename to src/aiidalab_qe/app/static/style.css
diff --git a/aiidalab_qe/app/static/welcome.jinja b/src/aiidalab_qe/app/static/welcome.jinja
similarity index 100%
rename from aiidalab_qe/app/static/welcome.jinja
rename to src/aiidalab_qe/app/static/welcome.jinja
diff --git a/aiidalab_qe/app/static/workflow_failure.jinja b/src/aiidalab_qe/app/static/workflow_failure.jinja
similarity index 100%
rename from aiidalab_qe/app/static/workflow_failure.jinja
rename to src/aiidalab_qe/app/static/workflow_failure.jinja
diff --git a/aiidalab_qe/app/static/workflow_summary.jinja b/src/aiidalab_qe/app/static/workflow_summary.jinja
similarity index 100%
rename from aiidalab_qe/app/static/workflow_summary.jinja
rename to src/aiidalab_qe/app/static/workflow_summary.jinja
diff --git a/aiidalab_qe/app/structures.py b/src/aiidalab_qe/app/structure/__init__.py
similarity index 100%
rename from aiidalab_qe/app/structures.py
rename to src/aiidalab_qe/app/structure/__init__.py
diff --git a/src/aiidalab_qe/app/submission/__init__.py b/src/aiidalab_qe/app/submission/__init__.py
new file mode 100644
index 00000000..7efb0473
--- /dev/null
+++ b/src/aiidalab_qe/app/submission/__init__.py
@@ -0,0 +1,672 @@
+# -*- coding: utf-8 -*-
+"""Widgets for the submission of bands work chains.
+
+Authors: AiiDAlab team
+"""
+from __future__ import annotations
+
+import os
+import typing as t
+from dataclasses import dataclass
+
+import ipywidgets as ipw
+import traitlets as tl
+from aiida import orm
+from aiida.common import NotExistent
+from aiida.engine import ProcessBuilderNamespace, submit
+from aiida_quantumespresso.common.types import ElectronicType, RelaxType, SpinType
+from aiidalab_widgets_base import ComputationalResourcesWidget, WizardAppWidgetStep
+from IPython.display import display
+
+from aiidalab_qe.app.common.setup_codes import QESetupWidget
+from aiidalab_qe.app.configuration.advanced import AdvancedSettings
+from aiidalab_qe.app.configuration.pseudos import PseudoFamilySelector
+from aiidalab_qe.app.configuration.workflow import WorkChainSettings
+from aiidalab_qe.app.parameters import DEFAULT_PARAMETERS
+from aiidalab_qe.workflows import QeAppWorkChain
+
+from .resource import ParallelizationSettings, ResourceSelectionWidget
+from .sssp import SSSPInstallWidget
+
+
+# The static input parameters for the QE App WorkChain
+# The dataclass does not include codes and structure which will be set
+# from widgets separately.
+# Relax type, electronic type, spin type, are str because they are used also
+# for serialized input of extras attributes of the workchain
+@dataclass(frozen=True)
+class QeWorkChainParameters:
+ protocol: str
+ relax_type: str
+ properties: t.List[str]
+ spin_type: str
+ electronic_type: str
+ overrides: t.Dict[str, t.Any]
+ initial_magnetic_moments: t.Dict[str, float]
+
+
+PROTOCOL_PSEUDO_MAP = {
+ "fast": "SSSP/1.2/PBE/efficiency",
+ "moderate": "SSSP/1.2/PBE/efficiency",
+ "precise": "SSSP/1.2/PBE/precision",
+}
+
+
+class SubmitQeAppWorkChainStep(ipw.VBox, WizardAppWidgetStep):
+ """Step for submission of a bands workchain."""
+
+ codes_title = ipw.HTML(
+ """
+
Codes
"""
+ )
+ codes_help = ipw.HTML(
+ """ Select the code to use for running the calculations. The codes
+ on the local machine (localhost) are installed by default, but you can
+ configure new ones on potentially more powerful machines by clicking on
+ "Setup new code".
"""
+ )
+
+ # This number provides a rough estimate for how many MPI tasks are needed
+ # for a given structure.
+ NUM_SITES_PER_MPI_TASK_DEFAULT = 6
+
+ # Warn the user if they are trying to run calculations for a large
+ # structure on localhost.
+ RUN_ON_LOCALHOST_NUM_SITES_WARN_THRESHOLD = 10
+
+ # Put a limit on how many MPI tasks you want to run per k-pool by default
+ MAX_MPI_PER_POOL = 20
+
+ input_structure = tl.Instance(orm.StructureData, allow_none=True)
+ process = tl.Instance(orm.WorkChainNode, allow_none=True)
+ previous_step_state = tl.UseEnum(WizardAppWidgetStep.State)
+ workchain_settings = tl.Instance(WorkChainSettings, allow_none=True)
+ pseudo_family_selector = tl.Instance(PseudoFamilySelector, allow_none=True)
+ advanced_settings = tl.Instance(AdvancedSettings, allow_none=True)
+ _submission_blockers = tl.List(tl.Unicode())
+
+ def __init__(self, qe_auto_setup=True, **kwargs):
+ self.message_area = ipw.Output()
+ self._submission_blocker_messages = ipw.HTML()
+
+ self.pw_code = ComputationalResourcesWidget(
+ description="pw.x:", default_calc_job_plugin="quantumespresso.pw"
+ )
+ self.dos_code = ComputationalResourcesWidget(
+ description="dos.x:",
+ default_calc_job_plugin="quantumespresso.dos",
+ )
+ self.projwfc_code = ComputationalResourcesWidget(
+ description="projwfc.x:",
+ default_calc_job_plugin="quantumespresso.projwfc",
+ )
+
+ self.resources_config = ResourceSelectionWidget()
+ self.parallelization = ParallelizationSettings()
+
+ self.set_selected_codes(DEFAULT_PARAMETERS)
+ self.set_resource_defaults()
+
+ self.pw_code.observe(self._update_state, "value")
+ self.pw_code.observe(self._update_resources, "value")
+ self.dos_code.observe(self._update_state, "value")
+ self.projwfc_code.observe(self._update_state, "value")
+
+ self.submit_button = ipw.Button(
+ description="Submit",
+ tooltip="Submit the calculation with the selected parameters.",
+ icon="play",
+ button_style="success",
+ layout=ipw.Layout(width="auto", flex="1 1 auto"),
+ disabled=True,
+ )
+
+ self.submit_button.on_click(self._on_submit_button_clicked)
+
+ # The SSSP installation status widget shows the installation status of
+ # the SSSP pseudo potentials and triggers the installation in case that
+ # they are not yet installed. The widget will remain in a "busy" state
+ # in case that the installation was already triggered elsewhere, e.g.,
+ # by the start up scripts. The submission is blocked while the
+ # potentials are not yet installed.
+ self.sssp_installation_status = SSSPInstallWidget(auto_start=qe_auto_setup)
+ self.sssp_installation_status.observe(self._update_state, ["busy", "installed"])
+ self.sssp_installation_status.observe(self._toggle_install_widgets, "installed")
+
+ # The QE setup widget checks whether there are codes that match specific
+ # expected labels (e.g. "pw-7.2@localhost") and triggers both the
+ # installation of QE into a dedicated conda environment and the setup of
+ # the codes in case that they are not already configured.
+ self.qe_setup_status = QESetupWidget(auto_start=qe_auto_setup)
+ self.qe_setup_status.observe(self._update_state, "busy")
+ self.qe_setup_status.observe(self._toggle_install_widgets, "installed")
+ self.qe_setup_status.observe(self._auto_select_code, "installed")
+
+ super().__init__(
+ children=[
+ self.codes_title,
+ self.codes_help,
+ self.pw_code,
+ self.dos_code,
+ self.projwfc_code,
+ self.resources_config,
+ self.parallelization,
+ self.message_area,
+ self.sssp_installation_status,
+ self.qe_setup_status,
+ self._submission_blocker_messages,
+ self.submit_button,
+ ]
+ )
+
+ @tl.observe("_submission_blockers")
+ def _observe_submission_blockers(self, change):
+ if change["new"]:
+ fmt_list = "\n".join((f"{item}" for item in sorted(change["new"])))
+ self._submission_blocker_messages.value = f"""
+
+
The submission is blocked, due to the following reason(s):
+
+
Resources
+ """
+ )
+ prompt = ipw.HTML(
+ """
+
+ Specify the resources to use for the pw.x calculation.
+
+
Parallelization
+ """
+ )
+ prompt = ipw.HTML(
+ """
+
+ Specify the number of k-points pools for the calculations.
+