reflectorch 1.0.0__tar.gz → 1.0.1__tar.gz

reflectorch-1.0.1/.github/workflows/draft-pdf.yml

@@ -0,0 +1,24 @@
+name: Draft PDF
+on: [push]
+
+jobs:
+  paper:
+    runs-on: ubuntu-latest
+    name: Paper Draft
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build draft PDF
+        uses: openjournals/openjournals-draft-action@master
+        with:
+          journal: joss
+          # This should be the path to the paper within your repo.
+          paper-path: paper/paper.md
+      - name: Upload
+        uses: actions/upload-artifact@v3
+        with:
+          name: paper
+          # This is the output path where Pandoc will write the compiled
+          # PDF. Note, this should be the same directory as the input
+          # paper.md
+          path: paper/paper.pdf

reflectorch-1.0.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Reflectorch Developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{reflectorch-1.0.0 → reflectorch-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reflectorch
-Version: 1.0.0
+Version: 1.0.1
 Summary: A Pytorch-based package for the analysis of reflectometry data
 Author-email: Vladimir Starostin <vladimir.starostin@uni-tuebingen.de>, Valentin Munteanu <valentin.munteanu@uni-tuebingen.de>
 Maintainer-email: Valentin Munteanu <valentin.munteanu@uni-tuebingen.de>, Alexander Hinderhofer <alexander.hinderhofer@uni-tuebingen.de>
@@ -51,27 +51,30 @@ Requires-Dist: twine; extra == "build"
 [![Python version](https://img.shields.io/badge/python-3.7%7C3.8%7C3.9%7C3.10%7C3.11%7C3.12-blue.svg)](https://www.python.org/)
 ![CI workflow status](https://github.com/schreiber-lab/reflectorch/actions/workflows/ci.yml/badge.svg)
 ![Repos size](https://img.shields.io/github/repo-size/schreiber-lab/reflectorch)
+[![CodeFactor](https://www.codefactor.io/repository/github/schreiber-lab/reflectorch/badge)](https://www.codefactor.io/repository/github/schreiber-lab/reflectorch)
 [![Jupyter Book Documentation](https://jupyterbook.org/badge.svg)](https://schreiber-lab.github.io/reflectorch/)
 <!-- [![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) -->
 
 
-**Reflectorch** is a machine learning Python package for the analysis of X-ray and neutron reflectometry data based on Pytorch (written by [Vladimir Starostin](https://github.com/StarostinV/) & [Valentin Munteanu](https://github.com/valentinsingularity)). It provides functionality for the fast simulation of reflectometry curves on the GPU, customizable setup of the physical parameterization model and neural network architecture via YAML configuration files, and prior-aware training of neural networks as described in our paper [Neural network analysis of neutron and X-ray reflectivity data incorporating prior knowledge](https://doi.org/10.1107/S1600576724002115).
+**Reflectorch** is a machine learning Python package for the analysis of X-ray and neutron reflectometry data, written by [Vladimir Starostin](https://github.com/StarostinV/) & [Valentin Munteanu](https://github.com/valentinsingularity) at the University of Tübingen. It provides functionality for the fast simulation of reflectometry curves on the GPU, customizable setup of the physical parameterization model and neural network architecture via YAML configuration files, and prior-aware training of neural networks as described in our paper [Neural network analysis of neutron and X-ray reflectivity data incorporating prior knowledge](https://doi.org/10.1107/S1600576724002115).
 
 ## Installation
 
-**Reflectorch** can be installed either from [![PyPi](https://img.shields.io/badge/PyPi-3776AB.svg?style=flat&logo=pypi&logoColor=white)](https://pypi.org/project/reflectorch/) via ``pip`` or from [![conda-forge](https://img.shields.io/badge/conda--forge-44A833.svg?style=flat&logo=conda-forge&logoColor=white)](https://anaconda.org/conda-forge/reflectorch/) via ``conda``:
+**Reflectorch** can be installed from [![PyPi](https://img.shields.io/badge/PyPi-3776AB.svg?style=flat&logo=pypi&logoColor=white)](https://pypi.org/project/reflectorch/) via ``pip``:
+
+<!-- or from [![conda-forge](https://img.shields.io/badge/conda--forge-44A833.svg?style=flat&logo=conda-forge&logoColor=white)](https://anaconda.org/conda-forge/reflectorch/) via ``conda``: -->
 
 ```bash
 pip install reflectorch
 ```
 
-or
+<!-- or
 
 ```bash
 conda install -c conda-forge reflectorch
-```
+``` -->
 
-Additionally, one can clone the entire Github repository and install the package in editable mode:
+Alternatively, one can clone the entire Github repository and install the package in editable mode:
 
 ```bash
 git clone https://github.com/schreiber-lab/reflectorch.git

{reflectorch-1.0.0 → reflectorch-1.0.1}/README.md

@@ -11,27 +11,30 @@
 [![Python version](https://img.shields.io/badge/python-3.7%7C3.8%7C3.9%7C3.10%7C3.11%7C3.12-blue.svg)](https://www.python.org/)
 ![CI workflow status](https://github.com/schreiber-lab/reflectorch/actions/workflows/ci.yml/badge.svg)
 ![Repos size](https://img.shields.io/github/repo-size/schreiber-lab/reflectorch)
+[![CodeFactor](https://www.codefactor.io/repository/github/schreiber-lab/reflectorch/badge)](https://www.codefactor.io/repository/github/schreiber-lab/reflectorch)
 [![Jupyter Book Documentation](https://jupyterbook.org/badge.svg)](https://schreiber-lab.github.io/reflectorch/)
 <!-- [![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) -->
 
 
-**Reflectorch** is a machine learning Python package for the analysis of X-ray and neutron reflectometry data based on Pytorch (written by [Vladimir Starostin](https://github.com/StarostinV/) & [Valentin Munteanu](https://github.com/valentinsingularity)). It provides functionality for the fast simulation of reflectometry curves on the GPU, customizable setup of the physical parameterization model and neural network architecture via YAML configuration files, and prior-aware training of neural networks as described in our paper [Neural network analysis of neutron and X-ray reflectivity data incorporating prior knowledge](https://doi.org/10.1107/S1600576724002115).
+**Reflectorch** is a machine learning Python package for the analysis of X-ray and neutron reflectometry data, written by [Vladimir Starostin](https://github.com/StarostinV/) & [Valentin Munteanu](https://github.com/valentinsingularity) at the University of Tübingen. It provides functionality for the fast simulation of reflectometry curves on the GPU, customizable setup of the physical parameterization model and neural network architecture via YAML configuration files, and prior-aware training of neural networks as described in our paper [Neural network analysis of neutron and X-ray reflectivity data incorporating prior knowledge](https://doi.org/10.1107/S1600576724002115).
 
 ## Installation
 
-**Reflectorch** can be installed either from [![PyPi](https://img.shields.io/badge/PyPi-3776AB.svg?style=flat&logo=pypi&logoColor=white)](https://pypi.org/project/reflectorch/) via ``pip`` or from [![conda-forge](https://img.shields.io/badge/conda--forge-44A833.svg?style=flat&logo=conda-forge&logoColor=white)](https://anaconda.org/conda-forge/reflectorch/) via ``conda``:
+**Reflectorch** can be installed from [![PyPi](https://img.shields.io/badge/PyPi-3776AB.svg?style=flat&logo=pypi&logoColor=white)](https://pypi.org/project/reflectorch/) via ``pip``:
+
+<!-- or from [![conda-forge](https://img.shields.io/badge/conda--forge-44A833.svg?style=flat&logo=conda-forge&logoColor=white)](https://anaconda.org/conda-forge/reflectorch/) via ``conda``: -->
 
 ```bash
 pip install reflectorch
 ```
 
-or
+<!-- or
 
 ```bash
 conda install -c conda-forge reflectorch
-```
+``` -->
 
-Additionally, one can clone the entire Github repository and install the package in editable mode:
+Alternatively, one can clone the entire Github repository and install the package in editable mode:
 
 ```bash
 git clone https://github.com/schreiber-lab/reflectorch.git

{reflectorch-1.0.0 → reflectorch-1.0.1}/documentation/installation.ipynb

@@ -15,7 +15,7 @@
     "tags": []
    },
    "source": [
-    "**Reflectorch** can be installed directly from the Python Packaging Index (PyPI) via the Python package installer **pip** or from the [conda-forge](https://anaconda.org/conda-forge/reflectorch) channel via the **conda** package installer. "
+    "**Reflectorch** can be installed directly from the Python Packaging Index (PyPI) via the Python package installer `pip`:"
    ]
   },
   {
@@ -27,22 +27,6 @@
     "```"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "or"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "```bash\n",
-    "conda install -c conda-forge reflectorch\n",
-    "```"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},

{reflectorch-1.0.0 → reflectorch-1.0.1}/paper/paper.md

@@ -13,7 +13,7 @@ authors:
     equal-contrib: true
   - name: Vladimir Starostin
     orcid: 0000-0003-4533-6256
-    affiliation: 1
+    affiliation: 2
     equal-contrib: true
   - name: Alexander Hinderhofer
     orcid: 0000-0001-8152-6386
@@ -29,8 +29,10 @@ authors:
     affiliation: 1
     corresponding: true
 affiliations:
- - name: University of Tübingen, Institute for Applied Physics, Auf der Morgenstelle 10, 72076 Tübingen, Germany
-   index: 1
+  - name: University of Tübingen, Institute of Applied Physics, Auf der Morgenstelle 10, 72076 Tübingen, Germany
+    index: 1
+  - name: University of Tübingen, Cluster of Excellence "Machine learning - new perspectives for science", Maria-von-Linden-Straße 6, 72076 Tübingen, Germany
+    index: 2
 
 date: 1 June 2024
 bibliography: paper.bib
@@ -44,7 +46,7 @@ We introduce `reflectorch`, a Python package which facilitates the full machine
 
 # Statement of need
 
-X-ray and neutron reflectometry (XRR and NR) are widely-used and indispensable experimental techniques for elucidating thin films and, generally, layered systems. Experimentalists, having measured a reflectometry curve, are faced with the task of obtaining the physical parameters corresponding to an assumed parameterization of the scattering length density (SLD) profile along the depth of the investigated sample. The inverse problem is non-trivial and generally ambiguous due to the lack of phase information and the existence of experimental limitations. Recent years have seen an increased interest in the fast analysis of reflectometry data using machine learning techniques, as such methods could be adapted for in-operando investigations at large scale facilities (i.e. synchrotron and neutron sources), potentially enabling closed loop experiments [@Pithan2023]. 
+X-ray and neutron reflectometry (XRR and NR) are widely-used and indispensable experimental techniques for elucidating the structure of interfaces and thin films, i.e. layered systems. Experimentalists, having measured a reflectometry curve, are faced with the task of obtaining the physical parameters corresponding to an assumed parameterization of the scattering length density (SLD) profile along the depth of the investigated sample. The inverse problem is non-trivial and generally ambiguous due to the lack of phase information and experimental limitations. Recent years have seen an increased interest in the fast analysis of reflectometry data using machine learning techniques, as such methods could be adapted for real-time investigations at large scale facilities (i.e. synchrotron and neutron sources), potentially enabling closed loop experiments [@Pithan2023]. 
 
 Our contribution to the open-source scientific software community is `reflectorch`, a deep learning package built in the Pytorch framework, which posseses a modular, object-oriented and customizable design. Reflectorch enables the user to simulate reflectivity curves in a fast and vectorized manner which takes advantage of the computing power of modern GPUs. The neural network architecture as well as the training callbacks and hyperparameters can be easily customized by editing YAML configuration files. As a result of the special training procedure, which incorporates minimum and maximum prior bounds for the parameters as described in [@Munteanu2024], the user is able to make use of prior knowledge about the investigated sample at inference time.  
 
@@ -57,18 +59,18 @@ Several types of parameterizations of the SLD profile are available, being imple
 
 The parameters are represented as an instance of the `BasicParams` class, which encapsulates the parameter values and their prior bounds, also taking care of scaling these values to neural-network friendly ranges. The prior sampler (a subclass of `PriorSampler`) is responsible for sampling the values of the parameters and their prior bounds from their predefined ranges, in which a subclass of `SamplingStrategy` can be used to further restrict the values of some parameters with respect to others (such as the interlayer roughness not exceeding a fraction of the thicknesses of the adjacent layers). Based on the sampled parameters and on the momentum transfer (q) values generated by a subclass of `QGenerator`, batches of reflectivity curves are simulated and augmented with experimentally-informed noise provided by a subclass of `IntensityNoiseGenerator` and scaled to a neural network-friendly range by a subclass of `CurvesScaler` (which is also responsible for restoring the scaled curves to their original ranges). 
 
-The trainer encapsulates the data loader, the Pytorch optimizer, the neural network, and other training hyperparameters, allowing the seamless training of the model and the saving of the resulting model weights and of the history of losses and learning rates. The neural network consists in an embedding network for the reflectivtiy curves and a multilayer perceptron. The architecture can be customized, different embedding networks for the reflectivity curves also being available. Callback objects can be used to control the training process, such as scheduling the learning rate or periodically saving the model weights. 
+The trainer encapsulates the data loader, the Pytorch optimizer, the neural network, and other training hyperparameters, allowing the seamless training of the model and the saving of the resulting model weights and of the history of losses and learning rates. The neural network consists of an embedding network for the reflectivity curves and a multilayer perceptron. The architecture can be easily customized. Different embedding networks for the reflectivity curves are also available. Callback objects can be used to control the training process, such as scheduling the learning rate or periodically saving the model weights. 
 
 Finally, the `EasyInferenceModel` class serves as a wrapper around trained models, simplifying the inference step. It also provides functionality for automatically downloading model weights and configuration files not locally available from a remote Huggingface repository.
 
 # Related Work
 
-There are several well-established packages designed for the conventional analysis of X-ray and neutron reflectometry data such as `GenX` [@GlaviGenX], `refnx` [@NelsonRefnx] and `refl1d` [@Maranville2020]. While several machine learning approaches pertaining to X-ray or neutron reflectometry have been proposed in various publications, `mlreflect` [@Greco2022Neural] is the only other properly packaged and documented software. Previously developed in our group, `mlreflect` is built in the Tensorflow deep learning framework and has limited functionality compared to `reflectorch` (specifically, the SLD profile is limited to a single film). Still, it has been successfully adopted for use in the scattering community such as in the publication [@Schumi-Marecek2024]. 
+There are several well-established packages designed for the conventional analysis of X-ray and neutron reflectometry data such as `GenX` [@GlaviGenX], `refnx` [@NelsonRefnx] and `refl1d` [@Maranville2020]. While several machine learning approaches pertaining to X-ray or neutron reflectometry have been proposed in various publications, `mlreflect` [@Greco2022Neural] is the only other properly packaged and documented software so far to the best of our knowledge. Previously developed in our group, `mlreflect` is built in the Tensorflow deep learning framework and has limited functionality compared to `reflectorch` (specifically, the SLD profile is limited to a single film). Still, it has been successfully adopted for use in the scattering community such as in the publication [@Schumi-Marecek2024]. 
 
 
 # Acknowledgements
 
-The research was part of a project (VIPR 05D23VT1 ERUMDATA) funded by the German Federal Ministry for Science and Education (BMBF). This work was partly supported by the consortium DAPHNE4NFDI in the context of the work of the NFDI e.V., funded by the German Research Foundation.
+The research was part of a project (VIPR 05D23VT1 ERUMDATA) funded by the German Federal Ministry for Science and Education (BMBF). This work was partly supported by the consortium DAPHNE4NFDI in the context of the work of the NFDI e.V., funded by the German Research Foundation. Supported by the Cluster of Excellence “Machine Learning – New Perspectives for Science” funded by the German Research Foundation under Germany’s Excellence Strategy – reference Number EXC 2064/1 - project number 390727645.
 
 # References
 

{reflectorch-1.0.0 → reflectorch-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reflectorch"
-version = "1.0.0"
+version = "1.0.1"
 authors = [
     {name = "Vladimir Starostin", email="vladimir.starostin@uni-tuebingen.de"},
     {name = "Valentin Munteanu", email="valentin.munteanu@uni-tuebingen.de"}

{reflectorch-1.0.0 → reflectorch-1.0.1}/reflectorch/data_generation/priors/sampler_strategies.py

@@ -283,7 +283,7 @@ def constrained_roughness_and_isld_sampler(
     params[..., roughness_mask] = roughnesses
 
     max_isld = torch.minimum(
-        params[..., sld_mask] * coef_isld,
+        torch.abs(params[..., sld_mask]) * coef_isld,
         total_max_bounds[..., isld_mask]
     )
     min_isld = total_min_bounds[..., isld_mask]

{reflectorch-1.0.0 → reflectorch-1.0.1}/reflectorch.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reflectorch
-Version: 1.0.0
+Version: 1.0.1
 Summary: A Pytorch-based package for the analysis of reflectometry data
 Author-email: Vladimir Starostin <vladimir.starostin@uni-tuebingen.de>, Valentin Munteanu <valentin.munteanu@uni-tuebingen.de>
 Maintainer-email: Valentin Munteanu <valentin.munteanu@uni-tuebingen.de>, Alexander Hinderhofer <alexander.hinderhofer@uni-tuebingen.de>
@@ -51,27 +51,30 @@ Requires-Dist: twine; extra == "build"
 [![Python version](https://img.shields.io/badge/python-3.7%7C3.8%7C3.9%7C3.10%7C3.11%7C3.12-blue.svg)](https://www.python.org/)
 ![CI workflow status](https://github.com/schreiber-lab/reflectorch/actions/workflows/ci.yml/badge.svg)
 ![Repos size](https://img.shields.io/github/repo-size/schreiber-lab/reflectorch)
+[![CodeFactor](https://www.codefactor.io/repository/github/schreiber-lab/reflectorch/badge)](https://www.codefactor.io/repository/github/schreiber-lab/reflectorch)
 [![Jupyter Book Documentation](https://jupyterbook.org/badge.svg)](https://schreiber-lab.github.io/reflectorch/)
 <!-- [![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) -->
 
 
-**Reflectorch** is a machine learning Python package for the analysis of X-ray and neutron reflectometry data based on Pytorch (written by [Vladimir Starostin](https://github.com/StarostinV/) & [Valentin Munteanu](https://github.com/valentinsingularity)). It provides functionality for the fast simulation of reflectometry curves on the GPU, customizable setup of the physical parameterization model and neural network architecture via YAML configuration files, and prior-aware training of neural networks as described in our paper [Neural network analysis of neutron and X-ray reflectivity data incorporating prior knowledge](https://doi.org/10.1107/S1600576724002115).
+**Reflectorch** is a machine learning Python package for the analysis of X-ray and neutron reflectometry data, written by [Vladimir Starostin](https://github.com/StarostinV/) & [Valentin Munteanu](https://github.com/valentinsingularity) at the University of Tübingen. It provides functionality for the fast simulation of reflectometry curves on the GPU, customizable setup of the physical parameterization model and neural network architecture via YAML configuration files, and prior-aware training of neural networks as described in our paper [Neural network analysis of neutron and X-ray reflectivity data incorporating prior knowledge](https://doi.org/10.1107/S1600576724002115).
 
 ## Installation
 
-**Reflectorch** can be installed either from [![PyPi](https://img.shields.io/badge/PyPi-3776AB.svg?style=flat&logo=pypi&logoColor=white)](https://pypi.org/project/reflectorch/) via ``pip`` or from [![conda-forge](https://img.shields.io/badge/conda--forge-44A833.svg?style=flat&logo=conda-forge&logoColor=white)](https://anaconda.org/conda-forge/reflectorch/) via ``conda``:
+**Reflectorch** can be installed from [![PyPi](https://img.shields.io/badge/PyPi-3776AB.svg?style=flat&logo=pypi&logoColor=white)](https://pypi.org/project/reflectorch/) via ``pip``:
+
+<!-- or from [![conda-forge](https://img.shields.io/badge/conda--forge-44A833.svg?style=flat&logo=conda-forge&logoColor=white)](https://anaconda.org/conda-forge/reflectorch/) via ``conda``: -->
 
 ```bash
 pip install reflectorch
 ```
 
-or
+<!-- or
 
 ```bash
 conda install -c conda-forge reflectorch
-```
+``` -->
 
-Additionally, one can clone the entire Github repository and install the package in editable mode:
+Alternatively, one can clone the entire Github repository and install the package in editable mode:
 
 ```bash
 git clone https://github.com/schreiber-lab/reflectorch.git

{reflectorch-1.0.0 → reflectorch-1.0.1}/reflectorch.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ README.md
 debug.py
 pyproject.toml
 .github/workflows/ci.yml
+.github/workflows/draft-pdf.yml
 configs/c1.yaml
 configs/c1_trained.yaml
 configs/c_L10_d100_s150_r30_ws5_q03_nq256.yaml
@@ -491,13 +492,13 @@ reflectorch/runs/utils.py
 tests/__init__.py
 tests/conftest.py
 tests/data/demo_scan.csv
-tests/data/test_preprocessed_curve_1.npz
 tests/fixtures/__init__.py
 tests/fixtures/data.py
-tests/fixtures/models.py
-tests/func/__init__.py
-tests/func/test_model.py
-tests/helpers/__init__.py
-tests/helpers/generate_data.py
 tests/unit/__init__.py
-tests/unit/test_preprocessing.py
+tests/unit/test_dataloader.py
+tests/unit/test_embedding_networks.py
+tests/unit/test_mlp.py
+tests/unit/test_preprocessing.py
+tests/unit/test_prior_sampler.py
+tests/unit/test_q_generator.py
+tests/unit/test_reflectivity.py

reflectorch-1.0.1/tests/fixtures/__init__.py

@@ -0,0 +1,8 @@
+from tests.fixtures.data import (
+    raw_data_with_preprocessing_params,
+)
+
+
+__all__ = [
+    "raw_data_with_preprocessing_params",
+]

{reflectorch-1.0.0 → reflectorch-1.0.1}/tests/fixtures/data.py

@@ -2,8 +2,6 @@ import pytest
 import numpy as np
 
 from reflectorch.paths import TEST_DATA_PATH
-from tests.helpers.generate_data import load_generated_data
-
 
 @pytest.fixture(
     params=["demo_scan.csv"],
@@ -26,20 +24,4 @@ def raw_data_with_preprocessing_params(request):
         sample_length=10.,
     )
 
-    return raw_data, preprocessing_params
-
-
-@pytest.fixture(
-    params=['test_preprocessed_curve_2'],
-    scope="session",
-)
-def preprocessed_data(request):
-    return load_generated_data(request.param)
-
-
-@pytest.fixture(
-    params=['test_raw_data_input_1'],
-    scope="session",
-)
-def raw_data_input(request):
-    pass
+    return raw_data, preprocessing_params

reflectorch-1.0.1/tests/unit/test_dataloader.py

@@ -0,0 +1,69 @@
+import pytest
+from reflectorch import ConstantQ, BasicExpIntensityNoise, BasicQNoiseGenerator, LogAffineCurvesScaler, SubpriorParametricSampler, \
+      Smearing, BasicDataset, ReflectivityDataLoader
+
+@pytest.mark.parametrize("calc_denoised_curves", [False, True])
+def test_dataloader(calc_denoised_curves):
+    prior_sampler = SubpriorParametricSampler(
+        param_ranges={
+            'thicknesses': [5.0, 300.0],
+            'roughnesses': [0.0, 30.0],
+            'slds': [0.0, 50.0],
+        },
+        bound_width_ranges={
+            'thicknesses': [1e-2, 300.0],
+            'roughnesses': [1e-2, 30.0],
+            'slds': [1e-2, 5.0],
+        },
+        model_name = 'standard_model',
+        device='cpu',
+        max_num_layers=3,
+        constrained_roughness = True,
+        max_thickness_share = 0.5,
+        scale_params_by_ranges=False,
+    )
+
+    q_generator = ConstantQ(
+    q = [0.02, 0.15, 128], 
+    device = 'cpu')
+
+    intensity_noise_generator = BasicExpIntensityNoise(
+    relative_errors = [0.0, 0.2],
+    abs_errors = 0.0,
+    consistent_rel_err = True,
+    logdist = False,
+    apply_shift = True,
+    shift_range = [-0.3, 0.3],
+    apply_scaling = True,
+    scale_range = [-0.02, 0.02],
+    apply_background = True,
+    background_range = [1.0e-10, 1.0e-8],
+    )
+
+    q_noise_generator = BasicQNoiseGenerator(
+        shift_std = 1.0e-3,
+        noise_std = [0., 1.0e-3],
+    )
+
+    smearing_generator = Smearing(
+        sigma_range = (0.0001, 0.005), 
+        constant_dq = True, 
+        gauss_num = 31, 
+        share_smeared = 0.2,
+    )
+
+    curves_scaler = LogAffineCurvesScaler(
+        weight = 0.2,
+        bias = 1.0,
+        eps = 1.0e-10,
+    )
+
+    data_loader = ReflectivityDataLoader(
+        q_generator=q_generator, 
+        prior_sampler=prior_sampler,
+        intensity_noise=intensity_noise_generator,
+        q_noise=q_noise_generator,
+        smearing=smearing_generator,
+        curves_scaler=curves_scaler,
+        calc_denoised_curves=calc_denoised_curves,
+        )

reflectorch-1.0.1/tests/unit/test_embedding_networks.py

@@ -0,0 +1,46 @@
+import pytest
+import torch
+from reflectorch.models.encoders import ConvEncoder, FnoEncoder
+
+@pytest.mark.parametrize("input_dim", [128, 140])
+@pytest.mark.parametrize("in_channels", [1])
+@pytest.mark.parametrize("hidden_channels", [(32, 64, 128, 256, 512), (16, 32, 64, 128, 256)])
+@pytest.mark.parametrize("dim_embedding", [64, 80])
+@pytest.mark.parametrize("dim_avpool", [1, 4])
+@pytest.mark.parametrize("use_batch_norm", [True, False])
+@pytest.mark.parametrize("activation", ['relu', 'gelu'])
+def test_cnn(input_dim, in_channels, hidden_channels, dim_embedding, dim_avpool, use_batch_norm, activation):
+    embedding_net = ConvEncoder(
+        in_channels=in_channels, 
+        hidden_channels=hidden_channels,
+        dim_latent=dim_embedding,
+        dim_avpool=dim_avpool,
+        use_batch_norm=use_batch_norm,
+        activation=activation,
+        )
+    
+    batch_size = 4
+    input_tensor = torch.randn((batch_size, in_channels, input_dim))
+
+    assert embedding_net(input_tensor).shape == (batch_size, dim_embedding)
+
+@pytest.mark.parametrize("input_dim", [128, 140])
+@pytest.mark.parametrize("in_channels", [1, 2, 3])
+@pytest.mark.parametrize("dim_embedding", [64, 80])
+@pytest.mark.parametrize("modes", [16, 32])
+@pytest.mark.parametrize("fusion_self_attention", [False, True])
+def test_fno(input_dim, in_channels, dim_embedding, modes, fusion_self_attention):
+    embedding_net = FnoEncoder(
+        ch_in = in_channels,
+        dim_embedding = dim_embedding,
+        modes = modes,
+        width_fno = 128,
+        n_fno_blocks = 2,
+        activation = 'gelu',
+        fusion_self_attention=fusion_self_attention,
+    )
+
+    batch_size = 4
+    input_tensor = torch.randn((batch_size, in_channels, input_dim))
+
+    assert embedding_net(input_tensor).shape == (batch_size, dim_embedding)

reflectorch-1.0.1/tests/unit/test_mlp.py

@@ -0,0 +1,34 @@
+import pytest
+import torch
+from reflectorch import ResidualMLP
+
+
+@pytest.mark.parametrize("dim_in", [256])
+@pytest.mark.parametrize("dim_out", [10])
+@pytest.mark.parametrize("residual", [False, True])
+@pytest.mark.parametrize("repeats_per_block", [1, 2])
+@pytest.mark.parametrize("activation", ['relu', 'rowdy'])
+@pytest.mark.parametrize("dropout_rate", [0, 0.2])
+def test_mlp(dim_in, dim_out, residual, repeats_per_block, activation, dropout_rate):
+    adaptive_activation = True if activation == 'rowdy' else False
+
+    mlp = ResidualMLP(
+        dim_in = dim_in,
+        dim_out = dim_out,
+        dim_condition = 0,
+        layer_width = 128,
+        num_blocks = 4,
+        repeats_per_block= repeats_per_block,
+        activation = activation,
+        use_batch_norm = True,
+        dropout_rate = dropout_rate,
+        residual = residual,
+        adaptive_activation = adaptive_activation,
+        conditioning = 'concat',
+    )
+
+    batch_size = 8
+    input_tensor = torch.randn((batch_size, dim_in))
+
+    assert mlp(input_tensor).shape == (batch_size, dim_out)
+

reflectorch-1.0.1/tests/unit/test_prior_sampler.py

@@ -0,0 +1,63 @@
+import pytest
+import torch
+from reflectorch import SubpriorParametricSampler
+
+@pytest.mark.parametrize("batch_size", [1, 128])
+@pytest.mark.parametrize("max_num_layers", [1, 2, 3, 4, 5, 10])
+@pytest.mark.parametrize("constrained_roughness", [True, False])
+def test_param_sampler_standard(batch_size, max_num_layers, constrained_roughness):
+    param_sampler = SubpriorParametricSampler(
+        param_ranges={
+            'thicknesses': [10.0, 500.0],
+            'roughnesses': [0.0, 60.0],
+            'slds': [-20.0, 100.0],
+        },
+        bound_width_ranges={
+            'thicknesses': [1e-2, 500.0],
+            'roughnesses': [1e-2, 60.0],
+            'slds': [1e-2, 10.0],
+        },
+        model_name = 'standard_model',
+        device='cpu',
+        max_num_layers=max_num_layers,
+        constrained_roughness = constrained_roughness,
+        max_thickness_share = 0.5,
+        scale_params_by_ranges=False,
+    )
+
+    sampled_params = param_sampler.sample(batch_size=batch_size)
+    assert sampled_params.parameters.shape == (batch_size, 3*max_num_layers+2)
+    assert torch.all(sampled_params.min_bounds <= sampled_params.parameters ) and torch.all(sampled_params.parameters <= sampled_params.max_bounds)
+
+
+@pytest.mark.parametrize("batch_size", [16])
+@pytest.mark.parametrize("max_num_layers", [1, 3, 5])
+@pytest.mark.parametrize("constrained_roughness", [True, False])
+@pytest.mark.parametrize("constrained_isld", [True, False])
+def test_param_sampler_absorption(batch_size, max_num_layers, constrained_roughness, constrained_isld):
+    param_sampler = SubpriorParametricSampler(
+        param_ranges={
+            'thicknesses': [10.0, 500.0],
+            'roughnesses': [0.0, 60.0],
+            'slds': [-20.0, 100.0],
+            'islds': [0.0, 10.0],
+        },
+        bound_width_ranges={
+            'thicknesses': [1e-2, 500.0],
+            'roughnesses': [1e-2, 60.0],
+            'slds': [1e-3, 20.0],
+            'islds': [1e-2, 10.0],
+        },
+        model_name = 'model_with_absorption',
+        device='cpu',
+        max_num_layers=max_num_layers,
+        constrained_roughness = constrained_roughness,
+        max_thickness_share = 0.5,
+        constrained_isld = constrained_isld,
+        max_sld_share = 0.2,
+        scale_params_by_ranges=False,
+    )
+
+    sampled_params = param_sampler.sample(batch_size=batch_size)
+    assert sampled_params.parameters.shape == (batch_size, 4*max_num_layers+3)
+    assert torch.all(sampled_params.min_bounds <= sampled_params.parameters ) and torch.all(sampled_params.parameters <= sampled_params.max_bounds)

reflectorch-1.0.1/tests/unit/test_q_generator.py

@@ -0,0 +1,25 @@
+import pytest
+from reflectorch import ConstantQ, VariableQ
+
+
+@pytest.mark.parametrize("batch_size", [1, 128])
+@pytest.mark.parametrize("q_range", [(0.01, 0.3, 128), (0.05, 0.1, 200)])
+def test_constantq(batch_size, q_range):
+    q_generator = ConstantQ(q=q_range, device='cpu')
+    q_values = q_generator.get_batch(batch_size=batch_size)
+
+    assert q_values.shape == (batch_size, q_range[-1])
+    assert q_values.min() == q_range[0]
+    assert q_values.max() == q_range[1]
+
+@pytest.mark.parametrize("batch_size", [1, 128])
+@pytest.mark.parametrize("q_min_range", [(0.005, 0.05), (0.01, 0.01)])
+@pytest.mark.parametrize("q_max_range", [(0.15, 0.5), (0.3, 0.3)])
+@pytest.mark.parametrize("n_q_range", [(64, 256), (128, 128)])
+def test_variableq(batch_size, q_min_range, q_max_range, n_q_range):
+    q_generator = VariableQ(q_min_range, q_max_range, n_q_range, device='cpu')
+    q_values = q_generator.get_batch(batch_size=batch_size)
+
+    assert n_q_range[0] <= q_values.shape[-1] <= n_q_range[1]
+    assert q_values.min() >= q_min_range[0]
+    assert q_values.max() <= q_max_range[1]