nomad-schema-plugin-simulation-workflow 1.0.1__py3-none-any.whl

simulationworkflowschema/phonon.py

@@ -0,0 +1,196 @@
+#
+# Copyright The NOMAD Authors.
+#
+# This file is part of NOMAD. See https://nomad-lab.eu for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import numpy as np
+
+from nomad.metainfo import SubSection, Quantity, Reference
+from nomad.datamodel.metainfo.workflow import Link
+from runschema.calculation import Dos, BandStructure
+from .general import (
+    ParallelSimulation,
+    SimulationWorkflowMethod,
+    SimulationWorkflowResults,
+    WORKFLOW_METHOD_NAME,
+    WORKFLOW_RESULTS_NAME,
+)
+from .thermodynamics import ThermodynamicsResults
+
+
+class PhononMethod(SimulationWorkflowMethod):
+    force_calculator = Quantity(
+        type=str,
+        shape=[],
+        description="""
+        Name of the program used to calculate the forces.
+        """,
+    )
+
+    mesh_density = Quantity(
+        type=np.float64,
+        shape=[],
+        unit='1 / meter ** 3',
+        description="""
+        Density of the k-mesh for sampling.
+        """,
+    )
+
+    random_displacements = Quantity(
+        type=bool,
+        shape=[],
+        description="""
+        Identifies if displacements are made randomly.
+        """,
+    )
+
+    with_non_analytic_correction = Quantity(
+        type=bool,
+        shape=[],
+        description="""
+        Identifies if non-analytical term corrections are applied to dynamical matrix.
+        """,
+    )
+
+    with_grueneisen_parameters = Quantity(
+        type=bool,
+        shape=[],
+        description="""
+        Identifies if Grueneisen parameters are calculated.
+        """,
+    )
+
+
+class PhononResults(ThermodynamicsResults):
+    n_imaginary_frequencies = Quantity(
+        type=int,
+        shape=[],
+        description="""
+        Number of modes with imaginary frequencies.
+        """,
+    )
+
+    n_bands = Quantity(
+        type=np.int32,
+        shape=[],
+        description="""
+        Number of phonon bands.
+        """,
+    )
+
+    n_qpoints = Quantity(
+        type=np.int32,
+        shape=[],
+        description="""
+        Number of q points for which phonon properties are evaluated.
+        """,
+    )
+
+    qpoints = Quantity(
+        type=np.float64,
+        shape=['n_qpoints', 3],
+        description="""
+        Value of the qpoints.
+        """,
+    )
+
+    group_velocity = Quantity(
+        type=np.float64,
+        shape=['n_qpoints', 'n_bands', 3],
+        unit='meter / second',
+        description="""
+        Calculated value of the group velocity at each qpoint.
+        """,
+    )
+
+    n_displacements = Quantity(
+        type=np.int32,
+        shape=[],
+        description="""
+        Number of independent displacements.
+        """,
+    )
+
+    n_atoms = Quantity(
+        type=np.int32,
+        shape=[],
+        description="""
+        Number of atoms in the simulation cell.
+        """,
+    )
+
+    displacements = Quantity(
+        type=np.float64,
+        shape=['n_displacements', 'n_atoms', 3],
+        unit='meter',
+        description="""
+        Value of the displacements applied to each atom in the simulation cell.
+        """,
+    )
+
+    dos = Quantity(
+        type=Reference(Dos),
+        shape=['n_data'],
+        description="""
+        Reference to the electronic density of states data.
+        """,
+    )
+
+    band_structure = Quantity(
+        type=Reference(BandStructure),
+        shape=['n_data'],
+        description="""
+        Reference to the electronic band structure data.
+        """,
+    )
+
+
+class Phonon(ParallelSimulation):
+    method = SubSection(sub_section=PhononMethod)
+
+    results = SubSection(sub_section=PhononResults)
+
+    def normalize(self, archive, logger):
+        super().normalize(archive, logger)
+
+        if not self._calculations or not self._calculations[0].band_structure_phonon:
+            return
+
+        if not self.method:
+            self.method = PhononMethod()
+            self.inputs.append(Link(name=WORKFLOW_METHOD_NAME, section=self.method))
+
+        if not self.results:
+            self.results = PhononResults()
+            self.outputs.append(Link(name=WORKFLOW_RESULTS_NAME, section=self.results))
+
+        ThermodynamicsResults.normalize(self.results, archive, logger)
+
+        last_calc = self._calculations[-1]
+
+        if not self.results.n_imaginary_frequencies:
+            n_imaginary = 0
+            for band_segment in last_calc.band_structure_phonon[-1].segment:
+                freq = band_segment.energies.magnitude
+                n_imaginary += np.count_nonzero(np.array(freq) < 0)
+            self.results.n_imaginary_frequencies = n_imaginary
+
+        SimulationWorkflowResults.normalize(self.results, archive, logger)
+
+        if not self.results.dos:
+            self.results.dos = last_calc.dos_phonon
+
+        if not self.results.band_structure:
+            self.results.band_structure = last_calc.band_structure_phonon

simulationworkflowschema/photon_polarization.py

@@ -0,0 +1,75 @@
+#
+# Copyright The NOMAD Authors.
+#
+# This file is part of NOMAD. See https://nomad-lab.eu for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import numpy as np
+
+from nomad.metainfo import SubSection, Quantity, Reference
+from runschema.method import BSE as BSEMethodology
+from runschema.calculation import Spectra
+from .general import (
+    SimulationWorkflowResults,
+    SimulationWorkflowMethod,
+    ParallelSimulation,
+)
+
+
+class PhotonPolarizationResults(SimulationWorkflowResults):
+    """Groups all polarization outputs: spectrum."""
+
+    n_polarizations = Quantity(
+        type=np.int32,
+        description="""
+        Number of polarizations for the phonons used for the calculations.
+        """,
+    )
+
+    spectrum_polarization = Quantity(
+        type=Reference(Spectra),
+        shape=['n_polarizations'],
+        description="""
+        Spectrum for a given polarization of the photon.
+        """,
+    )
+
+
+class PhotonPolarizationMethod(SimulationWorkflowMethod):
+    """Defines the full macroscopic dielectric tensor methodology: BSE method reference."""
+
+    # TODO add TDDFT methodology reference.
+
+    bse_method_ref = Quantity(
+        type=Reference(BSEMethodology),
+        description="""
+        BSE methodology reference.
+        """,
+    )
+
+
+class PhotonPolarization(ParallelSimulation):
+    """The PhotonPolarization workflow is generated in an extra EntryArchive FOR all polarization
+    EntryArchives present in the upload. It groups them for a set of given method parameters.
+
+    This entry is also recognized as the full macroscopic dielectric tensor entry (e.g. calculated
+    via BSE).
+    """
+
+    method = SubSection(sub_section=PhotonPolarizationMethod)
+
+    results = SubSection(sub_section=PhotonPolarizationResults)
+
+    def normalize(self, archive, logger):
+        super().normalize(archive, logger)

simulationworkflowschema/single_point.py

@@ -0,0 +1,273 @@
+#
+# Copyright The NOMAD Authors.
+#
+# This file is part of NOMAD. See https://nomad-lab.eu for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import numpy as np
+
+from nomad.metainfo import SubSection, Quantity, Reference
+from nomad.datamodel.metainfo.workflow import Link, Task
+from runschema.calculation import (
+    Dos,
+    BandStructure,
+    BandEnergies,
+    Density,
+    Potential,
+    Spectra,
+)
+from .general import (
+    SimulationWorkflowResults,
+    SimulationWorkflowMethod,
+    SimulationWorkflow,
+    INPUT_SYSTEM_NAME,
+    INPUT_METHOD_NAME,
+    OUTPUT_CALCULATION_NAME,
+    WORKFLOW_METHOD_NAME,
+    WORKFLOW_RESULTS_NAME,
+    resolve_difference,
+)
+
+
+class SinglePointResults(SimulationWorkflowResults):
+    n_scf_steps = Quantity(
+        type=int,
+        shape=[],
+        description="""
+        Number of self-consistent steps in the calculation.
+        """,
+    )
+
+    final_scf_energy_difference = Quantity(
+        type=np.float64,
+        shape=[],
+        unit='joule',
+        description="""
+        The difference in the energy between the last two scf steps.
+        """,
+    )
+
+    is_converged = Quantity(
+        type=bool,
+        shape=[],
+        description="""
+        Indicates if the convergence criteria were fullfilled.
+        """,
+    )
+
+    n_data = Quantity(
+        type=np.int32,
+        shape=[],
+        description="""
+        """,
+    )
+
+    dos = Quantity(
+        type=Reference(Dos),
+        shape=['n_data'],
+        description="""
+        Reference to the electronic density of states data.
+        """,
+    )
+
+    band_structure = Quantity(
+        type=Reference(BandStructure),
+        shape=['n_data'],
+        description="""
+        Reference to the electronic band structure data.
+        """,
+    )
+
+    eigenvalues = Quantity(
+        type=Reference(BandEnergies),
+        shape=['n_data'],
+        description="""
+        Reference to the eigenvalues.
+        """,
+    )
+
+    potential = Quantity(
+        type=Reference(Potential),
+        shape=['n_data'],
+        description="""
+        Reference to the potential data.
+        """,
+    )
+
+    density_charge = Quantity(
+        type=Reference(Density),
+        shape=['n_data'],
+        description="""
+        Reference to the charge density data.
+        """,
+    )
+
+    spectra = Quantity(
+        type=Reference(Spectra),
+        shape=['n_data'],
+        description="""
+        Reference to the spectral data.
+        """,
+    )
+
+
+class SinglePointMethod(SimulationWorkflowMethod):
+    method = Quantity(
+        type=str,
+        shape=[],
+        description="""
+        Calculation method used.
+        """,
+    )
+
+
+class SinglePoint(SimulationWorkflow):
+    method = SubSection(sub_section=SinglePointMethod)
+
+    results = SubSection(sub_section=SinglePointResults)
+
+    def normalize(self, archive, logger):
+        super().normalize(archive, logger)
+
+        if not self.tasks:
+            task = Task()
+            if self._systems:
+                task.m_add_sub_section(
+                    Task.inputs, Link(name=INPUT_SYSTEM_NAME, section=self._systems[0])
+                )
+            if self._methods:
+                task.m_add_sub_section(
+                    Task.inputs, Link(name=INPUT_METHOD_NAME, section=self._methods[0])
+                )
+            if self._calculations:
+                task.m_add_sub_section(
+                    Task.inputs,
+                    Link(name=OUTPUT_CALCULATION_NAME, section=self._calculations[0]),
+                )
+
+            self.tasks = [task]
+
+        if not self.method:
+            self.method = SinglePointMethod()
+
+        if not self.inputs:
+            self.m_add_sub_section(
+                SimulationWorkflow.inputs,
+                Link(name=WORKFLOW_METHOD_NAME, section=self.method),
+            )
+
+        if not self.results:
+            self.results = SinglePointResults()
+
+        if not self.outputs:
+            self.m_add_sub_section(
+                SimulationWorkflow.outputs,
+                Link(name=WORKFLOW_RESULTS_NAME, section=self.results),
+            )
+
+        if not self.method.method:
+            try:
+                # TODO keep extending for other SinglePoint
+                for method_name in ['dft', 'gw', 'bse', 'dmft']:
+                    if self._methods[-1].m_xpath(method_name):
+                        self.method.method = method_name.upper()
+                        break
+            except Exception:
+                pass
+
+        if not self._calculations:
+            return
+
+        last_calc = self._calculations[-1]
+        if not self.results.n_scf_steps:
+            self.results.n_scf_steps = len(last_calc.scf_iteration)
+
+        energies = [
+            scf.energy.total.value
+            for scf in last_calc.scf_iteration
+            if scf.energy is not None and scf.energy.total is not None
+        ]
+        delta_energy = resolve_difference(energies)
+        if not self.results.final_scf_energy_difference and delta_energy is not None:
+            self.results.final_scf_energy_difference = delta_energy
+
+        if not self.results.is_converged and delta_energy is not None:
+            try:
+                threshold = self._methods[-1].scf.threshold_energy_change
+                self.results.is_converged = bool(delta_energy <= threshold)
+            except Exception:
+                pass
+
+        if not self.results.dos and last_calc.dos_electronic:
+            self.results.dos = last_calc.dos_electronic
+
+        if not self.results.band_structure and last_calc.band_structure_electronic:
+            self.results.band_structure = last_calc.band_structure_electronic
+
+        if not self.results.eigenvalues and last_calc.eigenvalues:
+            self.results.eigenvalues = last_calc.eigenvalues
+
+        if not self.results.density_charge and last_calc.density_charge:
+            self.results.density_charge = last_calc.density_charge
+
+        if not self.results.potential and last_calc.potential:
+            self.results.potential = last_calc.potential
+
+        if not self.results.spectra and last_calc.spectra:
+            self.results.spectra = last_calc.spectra
+
+        SimulationWorkflowResults.normalize(self.results, archive, logger)
+
+
+class ParallelSimulation(SimulationWorkflow):
+    def normalize(self, archive, logger):
+        super().normalize(archive, logger)
+
+        if not self.tasks:
+            for n, calculation in enumerate(self._calculations):
+                inputs, outputs = (
+                    [],
+                    [Link(name=OUTPUT_CALCULATION_NAME, section=calculation)],
+                )
+                if self._calculations[n].system_ref:
+                    inputs.append(
+                        Link(
+                            name=INPUT_SYSTEM_NAME,
+                            section=self._calculations[n].system_ref,
+                        )
+                    )
+                elif len(self._calculations) == len(self._systems):
+                    inputs.append(
+                        Link(name=INPUT_SYSTEM_NAME, section=self._systems[n])
+                    )
+                else:
+                    continue
+                if self._calculations[n].method_ref:
+                    inputs.append(
+                        Link(
+                            name=INPUT_METHOD_NAME,
+                            section=self._calculations[n].method_ref,
+                        )
+                    )
+                elif len(self._calculations) == len(self._methods):
+                    inputs.append(
+                        Link(name=INPUT_METHOD_NAME, section=self._methods[n])
+                    )
+                elif len(self._methods) == 1:
+                    inputs.append(
+                        Link(name=INPUT_METHOD_NAME, section=self._methods[0])
+                    )
+                self.tasks.append(
+                    Task(name=f'Calculation {n}', inputs=inputs, outputs=outputs)
+                )

simulationworkflowschema/tb.py

@@ -0,0 +1,77 @@
+#
+# Copyright The NOMAD Authors.
+#
+# This file is part of NOMAD. See https://nomad-lab.eu for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+from nomad.metainfo import SubSection, Quantity, Reference
+from runschema.method import TB as TBMethodology, Method
+from .general import (
+    SimulationWorkflowResults,
+    ElectronicStructureOutputs,
+    SimulationWorkflowMethod,
+    SerialSimulation,
+)
+
+
+class FirstPrinciplesPlusTBResults(SimulationWorkflowResults):
+    """
+    Groups first principles and TB outputs: band gaps, DOS, band structures. The
+    ResultsNormalizer takes care of adding a label 'FirstPrinciples' or 'TB' in the method
+    `get_tb_workflow_properties`.
+    """
+
+    first_principles_outputs = SubSection(
+        sub_section=ElectronicStructureOutputs.m_def, repeats=False
+    )
+
+    tb_outputs = SubSection(sub_section=ElectronicStructureOutputs.m_def, repeats=False)
+
+
+class FirstPrinciplesPlusTBMethod(SimulationWorkflowMethod):
+    """
+    Specifies both the first principles and the TB input methodologies.
+    """
+
+    # TODO refine this referencing
+    first_principles_method_ref = Quantity(
+        type=Reference(Method),
+        description="""
+        First principles methodology reference.
+        """,
+    )
+
+    tb_method_ref = Quantity(
+        type=Reference(TBMethodology),
+        description="""
+        TB methodology reference.
+        """,
+    )
+
+
+class FirstPrinciplesPlusTB(SerialSimulation):
+    """
+    The TB (tight-binding) workflow is generated in an extra EntryArchive IF both
+    the first principles SinglePoint and the TB SinglePoint EntryArchives are present in the upload.
+    """
+
+    method = SubSection(sub_section=FirstPrinciplesPlusTBMethod)
+
+    results = SubSection(sub_section=FirstPrinciplesPlusTBResults)
+
+    def normalize(self, archive, logger):
+        if not self.results:  # creates Results section if not present
+            self.results = FirstPrinciplesPlusTBResults()
+
+        super().normalize(archive, logger)