nomad-material-processing 0.0.6__tar.gz → 0.0.8__tar.gz

nomad_material_processing-0.0.8/.vscode/settings.json

@@ -0,0 +1,19 @@
+{
+    "python.defaultInterpreterPath": ".pyenv/bin/python",
+    "python.terminal.activateEnvInCurrentTerminal": true,
+    "editor.rulers": [
+        90
+    ],
+    "editor.renderWhitespace": "all",
+    "editor.tabSize": 4,
+    "files.trimTrailingWhitespace": true,
+    "files.watcherExclude": {
+      "${workspaceFolder}/.pyenv/**": true,
+    },
+    "python.testing.unittestEnabled": false,
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.formatOnSave": true,
+    "[python]": {
+        "editor.defaultFormatter": "charliermarsh.ruff"
+    },
+}

{nomad-material-processing-0.0.6 → nomad_material_processing-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nomad-material-processing
-Version: 0.0.6
+Version: 0.0.8
 Summary: A plugin for NOMAD containing base sections for material processing.
 Author-email: Hampus Näsström <hampus.naesstroem@physik.hu-berlin.de>, Andrea Albino <andrea.albino@physik.hu-berlin.de>, Sebastian Brückner <sebastian.brueckner@ikz-berlin.de>
 License:                                  Apache License

{nomad-material-processing-0.0.6 → nomad_material_processing-0.0.8}/pyproject.toml

@@ -38,6 +38,48 @@ file = "LICENSE"
 "Homepage" = "https://github.com/FAIRmat-NFDI/nomad-material-processing"
 "Bug Tracker" = "https://github.com/FAIRmat-NFDI/nomad-material-processing/issues"
 
+[tool.ruff]
+include = ["src/*.py", "tests/*.py"]
+select = [
+    "E", # pycodestyle
+    "W", # pycodestyle
+    "PL", # pylint
+]
+ignore = [
+    "E501", # Line too long ({width} > {limit} characters)
+    "E701", # Multiple statements on one line (colon)
+    "E731", # Do not assign a lambda expression, use a def
+    "E402",  # Module level import not at top of file
+    "PLR0911", # Too many return statements
+    "PLR0912", # Too many branches
+    "PLR0913", # Too many arguments in function definition
+    "PLR0915", # Too many statements
+    "PLR2004", # Magic value used instead of constant
+    "PLW0603", # Using the global statement
+    "PLW2901", # redefined-loop-name
+    "PLR1714", # consider-using-in
+    "PLR5501", # else-if-used
+]
+fixable = ["ALL"]
+exclude = ["dependencies"]
+
+# Same as Black.
+line-length = 88
+indent-width = 4
+
+[tool.ruff.format]
+# use single quotes for strings.
+quote-style = "single"
+
+# indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
 [tool.setuptools.packages.find]
 where = [
     "src",

{nomad-material-processing-0.0.6 → nomad_material_processing-0.0.8}/src/nomad_material_processing/__init__.py

@@ -29,6 +29,8 @@ from nomad.datamodel.metainfo.basesections import (
     ElementalComposition,
     SynthesisMethod,
     CompositeSystem,
+    CompositeSystemReference,
+    SystemComponent,
 )
 from nomad.datamodel.data import (
     ArchiveSection,
@@ -53,12 +55,12 @@ m_package = Package(name='Material Processing')
 
 
 class Geometry(ArchiveSection):
-    '''
+    """
     Geometrical shape attributes of a system.
     Sections derived from `Geometry` represent concrete geometrical shapes.
-    '''
-    m_def = Section(
-    )
+    """
+
+    m_def = Section()
     volume = Quantity(
         type=float,
         description='The measure of the amount of space occupied in 3D space.',
@@ -70,12 +72,12 @@ class Geometry(ArchiveSection):
 
 
 class Parallelepiped(Geometry):
-    '''
-    Six-faced polyhedron with each pair of opposite faces parallel and equal in size, 
+    """
+    Six-faced polyhedron with each pair of opposite faces parallel and equal in size,
     characterized by rectangular sides and parallelogram faces.
-    '''
-    m_def = Section(
-    )
+    """
+
+    m_def = Section()
     height = Quantity(
         type=float,
         description='The z dimension of the parallelepiped.',
@@ -104,14 +106,14 @@ class Parallelepiped(Geometry):
             defaultDisplayUnit='millimeter',
             label='Length (y)',
         ),
-        unit='meter'
+        unit='meter',
     )
     surface_area = Quantity(
         type=float,
-        description='''
+        description="""
         The product of length and width, representing the total exposed area of the
         primary surface.
-        ''',
+        """,
         a_eln=ELNAnnotation(
             component=ELNComponentEnum.NumberEditQuantity,
             defaultDisplayUnit='millimeter ** 2',
@@ -122,16 +124,17 @@ class Parallelepiped(Geometry):
 
 
 class Miscut(ArchiveSection):
-    '''
-    The miscut in a crystalline substrate refers to 
-    the intentional deviation from a specific crystallographic orientation, 
+    """
+    The miscut in a crystalline substrate refers to
+    the intentional deviation from a specific crystallographic orientation,
     commonly expressed as the angular displacement of a crystal plane.
-    '''
+    """
+
     angle = Quantity(
         type=float,
-        description='''
+        description="""
         The angular displacement from the crystallographic orientation of the substrate.
-        ''',
+        """,
         a_eln=ELNAnnotation(
             component=ELNComponentEnum.NumberEditQuantity,
             defaultDisplayUnit='deg',
@@ -155,15 +158,16 @@ class Miscut(ArchiveSection):
         a_eln=ELNAnnotation(
             component=ELNComponentEnum.StringEditQuantity,
             label='Miscut Orientation [hkl]',
-        )
+        ),
     )
 
 
 class Dopant(ElementalComposition):
-    '''
-    A dopant element in a crystalline structure 
+    """
+    A dopant element in a crystalline structure
     is a foreign atom intentionally introduced into the crystal lattice.
-    '''
+    """
+
     doping_level = Quantity(
         type=float,
         description='The chemical doping level.',
@@ -176,23 +180,24 @@ class Dopant(ElementalComposition):
 
 
 class CrystalProperties(ArchiveSection):
-    '''
+    """
     Characteristics arising from the ordered arrangement of atoms in a crystalline structure.
-    These properties are defined by factors such as crystal symmetry, lattice parameters, 
+    These properties are defined by factors such as crystal symmetry, lattice parameters,
     and the specific arrangement of atoms within the crystal lattice.
-    '''
+    """
 
 
 class SubstrateCrystalProperties(CrystalProperties):
-    '''
+    """
     Crystallographic parameters such as orientation, miscut, and surface structure.
-    '''
+    """
+
     orientation = Quantity(
         type=str,
-        description='''
-        Alignment of crystal lattice with respect to a vector normal to the surface 
+        description="""
+        Alignment of crystal lattice with respect to a vector normal to the surface
         specified using Miller indices.
-        ''',
+        """,
         a_eln=ELNAnnotation(
             component=ELNComponentEnum.StringEditQuantity,
             label='Substrate Orientation (hkl)',
@@ -200,18 +205,19 @@ class SubstrateCrystalProperties(CrystalProperties):
     )
     miscut = SubSection(
         section_def=Miscut,
-        description='''
+        description="""
         Section describing any miscut of the substrate with respect to the substrate
         orientation.
-        ''',
+        """,
     )
 
 
 class Substrate(CompositeSystem):
-    '''
+    """
     A thin free standing sheet of material. Not to be confused with the substrate role
     during a deposition, which can be a `Substrate` with `ThinFilm`(s) on it.
-    '''
+    """
+
     m_def = Section()
     supplier = Quantity(
         type=str,
@@ -219,7 +225,7 @@ class Substrate(CompositeSystem):
         a_eln=ELNAnnotation(
             component=ELNComponentEnum.StringEditQuantity,
             label='Name of Supplier',
-        )
+        ),
     )
     supplier_id = Quantity(
         type=str,
@@ -239,10 +245,11 @@ class Substrate(CompositeSystem):
 
 
 class CrystallineSubstrate(Substrate):
-    '''
+    """
     The substrate defined in this class is composed of periodic arrangement of atoms
     and shows typical features of a crystal structure.
-    '''
+    """
+
     m_def = Section()
     geometry = SubSection(
         section_def=Geometry,
@@ -255,16 +262,17 @@ class CrystallineSubstrate(Substrate):
     dopants = SubSection(
         section_def=Dopant,
         repeats=True,
-        description='''
+        description="""
         Repeating section containing information on any dopants in the substrate.
-        ''',
+        """,
     )
 
 
 class ThinFilm(CompositeSystem):
-    '''
+    """
     A thin film of material which exists as part of a stack.
-    '''
+    """
+
     m_def = Section()
 
     geometry = SubSection(
@@ -273,56 +281,139 @@ class ThinFilm(CompositeSystem):
     )
 
 
-class ThinFilmStack(CompositeSystem):
-    '''
-    A stack of `ThinFilm`(s). Typically deposited on a `Substrate`.
-    '''
-    m_def = Section()
-    substrate = Quantity(
+class ThinFilmReference(CompositeSystemReference):
+    """
+    Class autogenerated from yaml schema.
+    """
+
+    lab_id = Quantity(
+        type=str,
+        a_eln=ELNAnnotation(
+            component=ELNComponentEnum.StringEditQuantity,
+            label='Thin Film ID',
+        ),
+    )
+    reference = Quantity(
+        type=ThinFilm,
+        a_eln=ELNAnnotation(
+            component=ELNComponentEnum.ReferenceEditQuantity,
+            label='Thin Film',
+        ),
+    )
+
+
+class SubstrateReference(CompositeSystemReference):
+    """
+    A section for describing a system component and its role in a composite system.
+    """
+
+    lab_id = Quantity(
+        type=str,
+        a_eln=ELNAnnotation(
+            component=ELNComponentEnum.StringEditQuantity,
+            label='Substrate ID',
+        ),
+    )
+    reference = Quantity(
         type=Substrate,
-        description='''
-        The substrate which the thin film layers of the thin film stack are deposited
-        on.
-        ''',
         a_eln=ELNAnnotation(
             component=ELNComponentEnum.ReferenceEditQuantity,
+            label='Substrate',
         ),
     )
-    layers = Quantity(
-        type=ThinFilm,
-        description='''
+
+
+class ThinFilmStack(CompositeSystem):
+    """
+    A stack of `ThinFilm`(s). Typically deposited on a `Substrate`.
+    """
+
+    m_def = Section(
+        a_eln=ELNAnnotation(
+            hide=[
+                'components',
+            ],
+        ),
+    )
+    layers = SubSection(
+        description="""
         An ordered list (starting at the substrate) of the thin films making up the
         thin film stacks.
-        ''',
+        """,
+        section_def=ThinFilmReference,
+        repeats=True,
+    )
+    substrate = SubSection(
+        description="""
+        The substrate which the thin film layers of the thin film stack are deposited
+        on.
+        """,
+        section_def=SubstrateReference,
+    )
+
+    def normalize(self, archive: 'EntryArchive', logger: 'BoundLogger') -> None:
+        """
+        The normalizer for the `ThinFilmStack` class.
+
+        Args:
+            archive (EntryArchive): The archive containing the section that is being
+            normalized.
+            logger (BoundLogger): A structlog logger.
+        """
+        self.components = []
+        if self.layers:
+            self.components = [
+                SystemComponent(system=layer.reference)
+                for layer in self.layers
+                if layer.reference
+            ]
+        if self.substrate.reference:
+            self.components.append(SystemComponent(system=self.substrate.reference))
+        super().normalize(archive, logger)
+
+
+class ThinFilmStackReference(CompositeSystemReference):
+    """
+    Class autogenerated from yaml schema.
+    """
+
+    m_def = Section()
+    lab_id = Quantity(
+        type=str,
+        a_eln=ELNAnnotation(
+            component=ELNComponentEnum.StringEditQuantity,
+        ),
+    )
+    reference = Quantity(
+        type=ThinFilmStack,
         a_eln=ELNAnnotation(
             component=ELNComponentEnum.ReferenceEditQuantity,
         ),
-        shape=["*"],
     )
 
 
 class SampleDeposition(SynthesisMethod):
-    '''
+    """
     The process of the settling of particles (atoms or molecules) from a solution,
     suspension or vapour onto a pre-existing surface, resulting in the growth of a
     new phase. [database_cross_reference: https://orcid.org/0000-0002-0640-0422]
 
     Synonyms:
      - deposition
-    '''
+    """
+
     m_def = Section(
-        links=[
-            "http://purl.obolibrary.org/obo/CHMO_0001310"
-        ],)
+        links=['http://purl.obolibrary.org/obo/CHMO_0001310'],
+    )
 
     def is_serial(self) -> bool:
-        '''
+        """
         Method for determining if the steps are serial. Can be overwritten by sub class.
         Default behavior is to return True if all steps start after the previous one.
 
         Returns:
             bool: Whether or not the steps are serial.
-        '''
+        """
         start_times = []
         durations = []
         for step in self.steps:
@@ -339,14 +430,14 @@ class SampleDeposition(SynthesisMethod):
         return True
 
     def normalize(self, archive: 'EntryArchive', logger: 'BoundLogger') -> None:
-        '''
+        """
         The normalizer for the `SampleDeposition` class.
 
         Args:
             archive (EntryArchive): The archive containing the section that is being
             normalized.
             logger (BoundLogger): A structlog logger.
-        '''
+        """
         super().normalize(archive, logger)
         if self.is_serial():
             tasks = []
@@ -357,8 +448,73 @@ class SampleDeposition(SynthesisMethod):
                 if previous is not None:
                     task.inputs.append(Link(name=previous.name, section=previous))
                 tasks.append(task)
-                previous=step
+                previous = step
             archive.workflow2.tasks = tasks
 
 
+class TimeSeries(ArchiveSection):
+    """
+    A time series of data during a process step.
+    This is an abstract class and should not be used directly.
+    Instead, it should be derived and the the units of the `value` and `set_value` should
+    be specified.
+
+    For example, a derived class could be `Temperature` with `value` in Kelvin:
+    ```python
+    class Temperature(TimeSeries):
+        value = TimeSeries.value.m_copy()
+        value.unit = "kelvin"
+        set_value = TimeSeries.set_value.m_copy()
+        set_value.unit = "kelvin"
+        set_value.a_eln.defaultDisplayUnit = "celsius"
+    ```
+    """
+
+    m_def = Section(
+        a_plot=dict(
+            # x=['time', 'set_time'],
+            # y=['value', 'set_value'],
+            x='time',
+            y='value',
+        ),
+    )
+    set_value = Quantity(
+        type=float,
+        description='The set value(s) (i.e. the intended values) set.',
+        shape=['*'],
+        a_eln=ELNAnnotation(
+            component=ELNComponentEnum.NumberEditQuantity,
+            label='Set value',
+        ),
+    )
+    set_time = Quantity(
+        type=float,
+        unit='s',
+        description="""
+        The process time when each of the set values were set.
+        If this is empty and only one set value is present, it is assumed that the value
+        was set at the start of the process step.
+        If two set values are present, it is assumed that a linear ramp between the two
+        values was set.
+        """,
+        shape=['*'],
+        a_eln=ELNAnnotation(
+            component=ELNComponentEnum.NumberEditQuantity,
+            defaultDisplayUnit='s',
+            label='Set time',
+        ),
+    )
+    value = Quantity(
+        type=float,
+        description='The observed value as a function of time.',
+        shape=['*'],
+    )
+    time = Quantity(
+        type=float,
+        unit='s',
+        description='The process time when each of the values were recorded.',
+        shape=['*'],
+    )
+
+
 m_package.__init_metainfo__()