nomad-material-processing 0.0.10__tar.gz → 1.0.0__tar.gz

nomad_material_processing-1.0.0/.github/workflows/mkdocs-deploy.yml

@@ -0,0 +1,28 @@
+name: Deploy MkDocs Site
+
+on:
+  push:
+    branches:
+      - main  # Triggers deployment on push to the main branch
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+
+      - name: Install Dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install mkdocs mkdocs-material==8.1.1 pymdown-extensions mkdocs-click
+
+      - name: Build and Deploy
+        run: |
+          mkdocs gh-deploy --force --remote-branch gh-pages

nomad_material_processing-1.0.0/.github/workflows/python-test.yml

@@ -0,0 +1,55 @@
+# This workflow will install Python dependencies, run tests, and lint with multiple version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python test
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+env:
+  UV_SYSTEM_PYTHON: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python_version: ["3.9", "3.10", "3.11"]
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{matrix.python_version}}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{matrix.python_version}}
+    - name: Install uv
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+    - name: Install dependencies
+      run: |
+        uv pip install -e '.[dev]'
+    - name: Test with pytest
+      run: |
+        pytest
+
+  ruff-linting:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: chartboost/ruff-action@v1
+        with:
+          args: "check ."
+
+  ruff-formatting:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: chartboost/ruff-action@v1
+        with:
+          args: "format . --check"

nomad_material_processing-1.0.0/CITATION.cff

@@ -0,0 +1,22 @@
+cff-version: 1.2.0
+title: nomad-material-processing
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+authors:
+  - given-names: Andrea
+    family-names: Albino
+    orcid: 'https://orcid.org/0000-0001-9280-7431'
+  - given-names: Sebastian
+    family-names: Brückner
+    orcid: 'https://orcid.org/0000-0002-5969-847X'
+  - given-names: Sarthak
+    family-names: Kapoor
+    orcid: 'https://orcid.org/0000-0002-1889-6998'
+  - given-names: Hampus
+    family-names: Näsström
+    orcid: 'https://orcid.org/0000-0002-3264-1692'
+repository-code: 'https://github.com/FAIRmat-NFDI/nomad-material-processing'
+url: 'https://fairmat-nfdi.github.io/nomad-material-processing/'
+license: MIT

{nomad_material_processing-0.0.10 → nomad_material_processing-1.0.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: nomad-material-processing
-Version: 0.0.10
+Version: 1.0.0
 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>
+Author-email: Sarthak Kapoor <sarthak.kapoor@physik.hu-berlin.de>, 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
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/
@@ -207,17 +207,21 @@ License:                                  Apache License
         
 Project-URL: Homepage, https://github.com/FAIRmat-NFDI/nomad-material-processing
 Project-URL: Bug Tracker, https://github.com/FAIRmat-NFDI/nomad-material-processing/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.9
-Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: nomad-lab>=1.2.1
+Requires-Dist: nomad-lab>=1.3.6
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: structlog>=22.3.0; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: structlog; extra == "dev"
 
 ![](https://github.com/FAIRmat-NFDI/nomad-material-processing/actions/workflows/publish.yml/badge.svg)
 ![](https://img.shields.io/pypi/pyversions/nomad-material-processing)
@@ -229,11 +233,34 @@ This is a plugin for [NOMAD](https://nomad-lab.eu) which contains base sections
 material processing.
 
 ## Getting started
-`nomad-material-processing` can be installed from PyPI using `pip`:
+`nomad-material-processing` can be installed from PyPI using `pip`. 
+
+> [!WARNING] 
+> Unfortunately, the current plugin mechanism is not supported by the latest nomad-lab version on PyPI and therefore an index url pointing to the NOMAD Gitlab registry needs to be added.
+
 ```sh
-pip install nomad-material-processing
+pip install nomad-material-processing --index-url https://gitlab.mpcdf.mpg.de/api/v4/projects/2187/packages/pypi/simple
 ```
 
+### Setting up your OASIS
+Read the [NOMAD plugin documentation](https://nomad-lab.eu/prod/v1/staging/docs/plugins/plugins.html#add-a-plugin-to-your-nomad) for all details on how to deploy the plugin on your NOMAD instance.
+
+You don't need to modify the ```nomad.yaml``` configuration file of your NOMAD instance, beacuse the package is pip installed and all the available modules (entry points) are loaded.
+To include, instead, only some of the entry points, you need to specify them in the ```include``` section of the ```nomad.yaml```. In the following lines, a list of all the available entry points:
+
+```yaml
+plugins:
+  include:
+    - "nomad_material_processing:schema"
+    - "nomad_material_processing.solution:schema"
+    - "nomad_material_processing.vapor_deposition.cvd:schema"
+    - "nomad_material_processing.vapor_deposition.pvd:schema"
+    - "nomad_material_processing.vapor_deposition.pvd:mbe_schema"
+    - "nomad_material_processing.vapor_deposition.pvd:pld_schema"
+    - "nomad_material_processing.vapor_deposition.pvd:sputtering_schema"
+    - "nomad_material_processing.vapor_deposition.pvd:thermal_schema"
+ ```
+
 ### Development
 This code is currently under development and for installing and contributing you should clone the repository:
 ```sh
@@ -243,5 +270,5 @@ cd nomad-material-processing
 
 And install the package in editable mode:
 ```sh
-pip install -e .
+pip install -e .[dev] --index-url https://gitlab.mpcdf.mpg.de/api/v4/projects/2187/packages/pypi/simple
 ```

nomad_material_processing-1.0.0/README.md

@@ -0,0 +1,49 @@
+![](https://github.com/FAIRmat-NFDI/nomad-material-processing/actions/workflows/publish.yml/badge.svg)
+![](https://img.shields.io/pypi/pyversions/nomad-material-processing)
+![](https://img.shields.io/pypi/l/nomad-material-processing)
+![](https://img.shields.io/pypi/v/nomad-material-processing)
+
+# NOMAD's Material Processing Plugin
+This is a plugin for [NOMAD](https://nomad-lab.eu) which contains base sections for
+material processing.
+
+## Getting started
+`nomad-material-processing` can be installed from PyPI using `pip`. 
+
+> [!WARNING] 
+> Unfortunately, the current plugin mechanism is not supported by the latest nomad-lab version on PyPI and therefore an index url pointing to the NOMAD Gitlab registry needs to be added.
+
+```sh
+pip install nomad-material-processing --index-url https://gitlab.mpcdf.mpg.de/api/v4/projects/2187/packages/pypi/simple
+```
+
+### Setting up your OASIS
+Read the [NOMAD plugin documentation](https://nomad-lab.eu/prod/v1/staging/docs/plugins/plugins.html#add-a-plugin-to-your-nomad) for all details on how to deploy the plugin on your NOMAD instance.
+
+You don't need to modify the ```nomad.yaml``` configuration file of your NOMAD instance, beacuse the package is pip installed and all the available modules (entry points) are loaded.
+To include, instead, only some of the entry points, you need to specify them in the ```include``` section of the ```nomad.yaml```. In the following lines, a list of all the available entry points:
+
+```yaml
+plugins:
+  include:
+    - "nomad_material_processing:schema"
+    - "nomad_material_processing.solution:schema"
+    - "nomad_material_processing.vapor_deposition.cvd:schema"
+    - "nomad_material_processing.vapor_deposition.pvd:schema"
+    - "nomad_material_processing.vapor_deposition.pvd:mbe_schema"
+    - "nomad_material_processing.vapor_deposition.pvd:pld_schema"
+    - "nomad_material_processing.vapor_deposition.pvd:sputtering_schema"
+    - "nomad_material_processing.vapor_deposition.pvd:thermal_schema"
+ ```
+
+### Development
+This code is currently under development and for installing and contributing you should clone the repository:
+```sh
+git clone git@github.com:FAIRmat-NFDI/nomad-material-processing.git
+cd nomad-material-processing
+```
+
+And install the package in editable mode:
+```sh
+pip install -e .[dev] --index-url https://gitlab.mpcdf.mpg.de/api/v4/projects/2187/packages/pypi/simple
+```

nomad_material_processing-1.0.0/docs/assets/.gitignore

@@ -0,0 +1 @@
+nomad-oasis*.zip

nomad_material_processing-1.0.0/docs/contact.md

@@ -0,0 +1,22 @@
+
+
+NOMAD is an open source project that warmly welcomes community projects, contributions, suggestions, bug fixes, and constructive feedback. The contributors to this documentation page are part of the [FAIRmat Area A - Synthesis team](https://www.fairmat-nfdi.eu/fairmat/about-fairmat/team-fairmat).
+
+You can reach us by different channels.
+Best option is to join our [NOMAD Discord channel](https://discord.gg/Gyzx3ukUw8) and ask us there directly.
+
+You can also send as directly an email to the main contributors list:
+
+| Name | E-mail     | Topics | Github profiles |
+|------|------------|--------|-----------------|
+| Dr. Andrea Albino | [andrea.albino@physik.hu-berlin.de](mailto:andrea.albino@physik.hu-berlin.de) | CVD | [@aalbino2](https://github.com/aalbino2) |
+| Dr. Hampus Näsström | [hampus.naesstroem@physik.hu-berlin.de](mailto:hampus.naesstroem@physik.hu-berlin.de) | PVD | [@hampusnasstrom](https://github.com/hampusnasstrom) |
+| Sarthak Kapoor, MSc. | [sarthak.kapoor@physik.hu-berlin.de](mailto:sarthak.kapoor@physik.hu-berlin.de) | Solutions | [@ka-sarthak](https://github.com/ka-sarthak) |
+| Dr. José Marquez | [josemarquez@physik.hu-berlin.de](mailto:josemarquez@physik.hu-berlin.de) | General | [@Pepe-Marquez](https://github.com/Pepe-Marquez) |
+| Dr. Sebastian Brückner (**Coordinator**) | [sebastian.brueckner@physik.hu-berlin.de](mailto:sebastian.brueckner@physik.hu-berlin.de) | General | [@budschi](https://github.com/budschi) |
+
+
+Alternatively, you can also:
+
+- Open an [**issue**](https://github.com/FAIRmat-NFDI/nomad-material-processing/issues) in the [Github project](https://github.com/FAIRmat-NFDI/nomad-material-processing), and tag any of us.
+

nomad_material_processing-1.0.0/docs/explanation/data_model.md

@@ -0,0 +1,193 @@
+## NOMAD Material Processing: a Community plugin
+
+The NOMAD Material Processing Plugin contains schemas for different synthesis methods.
+An overview of the package structure is shown below.
+
+### Technical description
+
+There are some technical aspects to understand the Python package built for this plugin, they are not crucial for the data model understanding itself:
+
+- It is structured according to the [src layout](https://packaging.python.org/en/latest/discussions/src-layout-vs-flat-layout/).
+- It is a [regular Python package](https://docs.python.org/3/reference/import.html#regular-packages), i. e., the structure is defined by the presence of `__init__.py` files. Each of these files contains one or multiple [entry points](https://nomad-lab.eu/prod/v1/staging/docs/howto/plugins/plugins.html#plugin-entry-points). These are used to load a portion of the code within your NOMAD through a specific section in the `nomad.yaml` file.
+- It is pip installable. The `project.toml` file defines what will be installed, the dependencies, further details. The **entry points** included are listed in this file.
+
+```text
+nomad-material-processing/
+├── docs
+├── pyproject.toml
+├── README.md
+├── src
+│   └── nomad_material_processing
+│       ├── __init__.py
+│       ├── utils.py
+│       ├── general.py
+│       ├── vapor_deposition
+│       │   ├── __init__.py
+│       │   ├── general.py
+│       │   ├── cvd
+│       │   │   ├── __init__.py
+│       │   │   ├── general.py
+│       │   │   └── movpe.py
+│       │   └── pvd
+│       │       ├── __init__.py
+│       │       ├── general.py
+│       │       ├── mbe.py
+│       │       ├── pld.py
+│       │       ├── sputtering.py
+│       │       └── thermal.py
+│       └── solution
+│           ├── __init__.py
+│           ├── general.py
+│           └── utils.py
+└── tests
+```
+
+### Data model description
+
+Each method has a dedicated [module](https://docs.python.org/3/tutorial/modules.html), i. e., a python file.
+
+#### nomad_material_processing.general
+
+A very general module containing several categories of classes:
+
+- an abstract process class `SampleDeposition` that is inherited in the specific processes such as MOVPE, MBE, PLD, etc.
+- `Substrate` and `CrystallineSubstrate` entities, the support used in `SampleDeposition` activities.
+- `ThinFilm` entity, usually created during `SampleDeposition` activities.
+- `ThinFilmStack` in case of processes producing multilayer samples. This class also contains a reference to the `Substrate`.
+- `Geometry` and its [subclasses](../reference/references.md#subclass), defining the commonly found macroscopic shapes of a sample. It is a [subsection](../reference/references.md#subsection) composed within the `Substrate`. They include `Parallelepiped`, `SquareCuboid`, `RectangleCuboid`, `TruncatedCone`, `Cylinder`, `CylinderSector`, `IrregularParallelSurfaces`.
+- `Miscut` another [subsection](../reference/references.md#subsection) of  `Substrate` to specify the miscut of the orientation of the surface in terms of angular deviation toward crystallographic directions.
+- `CrystalProperties` and `ElectronicProperties`, found as [subsection](../reference/references.md#subsection) of sample entities that need these parameters.
+- simple activities performed on samples: `Etching`, `Annealing`, `Cleaning`. They also include a `Recipe` that can be referenced inside to avoid repetition for routine tasks.
+- `TimeSeries` a general class that shapes every kind of parameters logged along a time window. The quantities referring to the measured parameter are `value` and `time`. `set_value` and `set_time` can also be specified, as they usually differ from the measured ones. Several [subclasses](../reference/references.md#subclass) inheriting from this one can be found nested in the package.
+
+#### nomad_material_processing.vapor_deposition.general
+
+The classes and now specified toward a specified group of techniques. The master class in this module is `VaporDeposition`, inheriting from `SampleDeposition`.
+
+The other classes found here are specifying the [subsections](../reference/references.md#subsection) found in the steps of the `VaporDeposition` process.
+`VaporDepositionStep` contains three [subsections](../reference/references.md#subsection) allowing to describe the parameters usually recorded during an experiment:
+
+- `VaporDepositionSource` the metadata on which kind of source will bring the raw material in the reaction chamber.
+This class is in turn composed by three distinct elements, namely the `Component` material to be evaporated, the `EvaporationSource` that is the element that produces the vapor, and `MolarFlowRate` that is a time series recording the molar flux exiting the source. This is used as a list within the `VaporDepositionStep` because many sources can be present at the same time.
+- `SampleParameter` this [subsection](../reference/references.md#subsection) hosts the references to the `ThinFilm` deposited and the `ThinFilmStack` or `Substrate` used as support of the deposition. This [subsection](../reference/references.md#subsection) is also used to record sample-specific parameters in the process, such as temperature, or growth rate. This is a list because many samples can be grown at the same time.
+- `ChamberEnvironment` collects the metadata connected to the whole reaction chamber that cannot be linked to one single sample. It usually contains temperature or `GasFlow` [subsections](../reference/references.md#subsection).
+
+These three [subsections](../reference/references.md#subsection) are the backbone of the `VaporDeposition` process and they are usually inherited whenever a specific experiment requires to extend them.
+
+#### nomad_material_processing.vapor_deposition.cvd.general
+
+This module contains specifications of `VaporDepositionSource` and `TimeSeries` commonly adopted in CVD techniques:
+
+Sources for CVD are inheriting from `CVDSource`, that is in turn a `VaporDepositionSource`.
+
+- `BubblerSource` defines a bubbler commonly used in CVD for liquid precursors.
+- `FlashSource` the vapor is generated by a `FlashEvaporator`.
+- `MistSource` another kind of source adopted in CVD.
+- `GasCylinderSource` a simple cylinder containing some gas phase precursor. In this case the `EvaporationSource` [subclass](../reference/references.md#subclass), called `GasCylinderEvaporator`, is not really evaporating as the precursor is already at the gas state.
+- `GasLineSource` used for gaseous precursors that are provided through a stable installation sourcing gas from facilities external to the lab.
+
+`TimeSeries` used in CVD are:
+- `Rotation` specifies rotation frequency of the substrate holder in the chamber
+- `PartialVaporPressure` as [subclass](../reference/references.md#subclass) of `Pressure`
+- `PushPurgeGasFlow` contains two `VolumetricFlowRate` [subsections](../reference/references.md#subsection) that record the source and drain fluxes of the carries gas in the chamber.
+
+#### nomad_material_processing.vapor_deposition.cvd.movpe
+
+
+
+#### nomad_material_processing.vapor_deposition.pvd
+#### nomad_material_processing.vapor_deposition.pvd.general
+#### nomad_material_processing.vapor_deposition.pvd.mbe
+#### nomad_material_processing.vapor_deposition.pvd.pld
+#### nomad_material_processing.vapor_deposition.pvd.sputtering
+#### nomad_material_processing.vapor_deposition.pvd.thermal
+#### nomad_material_processing.solution.general
+
+`solution.general` module contains the following entry sections (used to create
+NOMAD [entries](https://nomad-lab.eu/prod/v1/docs/reference/glossary.html#entry)):
+
+##### `Solution`
+Describes liquid solutions by extending the
+[`CompositeSystem`](https://nomad-lab.eu/prod/v1/docs/howto/customization/base_sections.html#system) with quantities: _pH_, _mass_,
+_calculated_volume_, _measured_volume_, _density_, and sub-sections:
+_solvents_, _solutes_, and _solution_storage_.
+
+```py
+# pseudocode for `Solution` datamodel
+class Solution(CompositeSystem, EntryData):
+    ph_value: float
+    mass: float
+    calculated_volume: float
+    measured_volume: float
+    density: float
+    components: list[
+        Union(
+            SolutionComponent,
+            SolutionComponentReference,
+        )
+    ]
+    solutes: list[SolutionComponent]
+    solvents: list[SolutionComponent]
+    solution_storage: SolutionStorage
+```
+
+!!! hint
+    The _measured_volume_ field is user-defined. By default, the automation in
+    `Solution` uses _calculated_volume_, but if _measured_volume_ is provided, it will take
+    precedence. This is useful when the final solution volume differs from the sum of its
+    component volumes, and should be specified by the user.
+The _components_ sub-section, inherited from `CompositeSystem` and re-defined, is used to describe
+a list of components used in the solution. Each of them contributes to the _mass_ and
+_calculated_volume_ of the solution. The component can either nest a
+sub-section describing its composition, or can be another `Solution` entry connected
+via reference.
+These options are are handled by
+`SolutionComponent` and `SolutionComponentReference` sections respectively.
+
+Let's take a closer look at each of them.
+
+
+`SolutionComponent` extends `PureSubstanceComponent` with quantities:
+_component_role_, _mass_, _volume_, _density_, and sub-section: _molar_concentration_.
+The _pure_substance_ sub-section inherited from `PureSubstanceComponent` specifies the
+chemical compound. This information along with the mass of the component and
+total volume of the solution is used to automatically determine the molar concentration of
+the component, populating the corresponding sub-section.
+Based on the _component_role_, the components are copied over to either
+`Solution.solvents` or `Solution.solutes`.
+```py
+class SolutionComponent(PureSubstanceComponent):
+    component_role: Enum('Solvent', 'Solute')
+    mass: float
+    volume: float
+    density: float
+    molar_concentration: MolarConcentration
+```
+
+
+`SolutionComponentReference` makes a reference to another `Solution` entry and specifies
+the amount used. Based on this, _solutes_ and _solvents_ of the referenced solution are
+copied over to the first solution. Their mass and volume are adjusted based on the
+amount of the referenced solution used.
+```py
+class SolutionComponentReference(SystemComponent):
+    mass: float
+    volume: float
+    system: Solution
+```
+
+Both `Solution.solvents` and `Solution.solutes` are a list of `SolutionComponent`. The
+molar concentration of each of them is automatically determined. Additionally, if the
+list has multiple `SolutionComponent` representing the same chemical entity, there are
+combined into one.
+
+The _solution_storage_ uses `SolutionStorage` section to describe storage conditions
+, i.e., temperature and atmosphere, along with preparation and expiry dates.
+
+##### `SolutionPreparation`
+Extends [`Process`](https://nomad-lab.eu/prod/v1/docs/howto/customization/base_sections.html#process)
+to describe the recipe for solution preparation. It generates a `Solution` entry based
+on the data added to it.
+
+
+!!! todo: add description of each module

nomad_material_processing-1.0.0/docs/explanation/levelsofschema.md

@@ -0,0 +1,42 @@
+# Levels of schemas in NOMAD
+
+It is important to understand the structure and relationship of different types of schemas in NOMAD. Here we break down the levels of schemas and how they interact. For detailed information, please visit the [official NOMAD documentation](https://nomad-lab.eu/prod/v1/staging/docs/explanation/data.html#schema).
+
+## Types of Schemas in NOMAD
+
+NOMAD categorizes its schemas into multiple levels, each serving distinct purposes while ensuring consistent data organization and interoperability:
+
+1. **Basic Architecture Sections**: These define the overall structure of any entry within NOMAD, regardless of the particular data type. They provide a shared, high-level framework applicable across different use cases, ensuring that every entry adheres to a consistent format. `EntryData` and `ArchiveSection` are the two relevant classes to be mentioned here.
+Every entry in NOMAD must inherit from `EntryData`, whenever a class is only used as a [subsection](../reference/references.md#subsection) composed within a more general one, inheriting from `ArchiveSection` is enough.
+
+2. **Base Sections**: These are central to NOMAD's data model and are designed to maintain interoperability between different database entries. The base sections follow an entity-activity model tailored for materials science, capturing essential relationships between key entities like samples, instruments, processes, measurements, analyses, experiments, and simulations. The goal is to provide standardized structures for data representation.
+
+
+	!!! Note
+        Base sections in NOMAD are abstract and should not be instantiated directly. Instead, users must implement these sections in their own schemas (referred to as user schemas) by inheriting from a base section and `nomad.datamodel.EntryData`. Users are strongly encouraged to use the most specialized section available for their use case.
+
+
+3. **Community/Standard Plugins**: FAIRmat offers standardized schemas for common methods, processes, and instruments that are generalized and not tied to any individual lab or setup. These schemas are derived from recurring patterns identified across user schemas. Users can inherit from these standard plugins in a similar manner as the base sections, further specializing them as needed while still maintaining a consistent structure for broader community use.
+FAIRmat's Area A for synthesis data provides two community plugins, NOMAD Measurements and NOMAD Materials Processing.
+
+4. **User Defined Sections**: These schemas are developed by users and are tailored for a method or an instrument, a lab, or a research institute. They build upon the base sections and community plugins, tailoring them to meet specific research needs. In this level, users can define more specialized structures that directly reflect the unique characteristics of their experiments or simulations.
+
+## How These Schemas Relate to Each Other
+
+The relationships between these schema levels can be visualized as a layered model:
+
+- **Basic Architecture and Base Sections**: At the core, ensuring interoperability and defining the primary structures.
+
+- **Community/Standard Plugins**: Inherit and specialize the base sections and provide generalized versions of common user schemas, making them clearly shaped on distinct fields of materials science while still allowing broad applicability across the community.
+
+- **User Schemas**: Inherit and specialize community plugins sections, if available, or the base sections according to given requirements.
+
+## Encouraged Usage
+
+NOMAD encourages users to first explore the available community/standard plugins and base sections before developing their own schemas. By doing so, they can maximize interoperability and benefit from established structures, while still retaining the flexibility to adapt the schema to their unique needs.
+
+The figure below illustrates these schema levels and the recommended workflow for schema development within NOMAD.
+
+In next documentation sections, an overview of the available methods will be provided.
+
+![Levels of schema](../assets/levelsschema.png)