artof 1.1.0__tar.gz

artof-1.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Carl Magnus Meier
+
+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.

artof-1.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: artof
+Version: 1.1.0
+Summary: The ARTOF is a tool to read, process and analyze data collected from angle resolved time of flight (ARToF) sensors of the PS-ISRR.
+Home-page: https://codebase.helmholtz.cloud/carl.meier/artof
+Author: Carl Magnus Meier
+Author-email: magnus.meier@helmholtz-berlin.de
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: IPython
+Requires-Dist: plotly
+Requires-Dist: anywidget
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# artof
+
+The artof package is a jupyter notebook tool to read, process and analyze data collected from angle
+resolved time of flight (ARTOF) sensors.
+
+## Getting started
+
+To use this package python version >=3.10 is needed. The installation can be done using the command:
+
+```bash
+pip install artof
+```
+
+## Documentation
+
+The documentation can be found [here](https://artof-42d889.pages.hzdr.de/main/). It is automatically
+generated from the docstrings in all python classes.
+
+## Workflow
+
+The implementation of a new feature should be conducted as follows:
+
+1. Create a new branch with a sensible name as a fork from `dev`.
+2. Implement features including documentation.
+3. If required, make changes to the Sphinx documentation under `docs/source/`.
+4. Check if all existing tests are still working (cmd: `pytest`) and write new test functions.
+5. If there were changes to `dev` since the initial fork, merge it into your branch and resolve
+   conflicts. Check again if all tests are running.
+6. Make sure the pylint rating of each file is 8 or higher. To do so run
+
+```bash
+pylint src/artof/{file}
+```
+
+7. Update documentation in the `./docs` folder using `.rst` and `sphinx`. For automatic doc
+   generation use `.. automodule:: artof.{module}` or `.. autoclass:: artof.{module}.{class}`. Do
+   not forget to add new `.rst`-files to index.
+8. Test the doc generation and ensure there are no warnings (else the pipeline will fail). To do
+   so run
+
+```bash
+sphinx-build -M html docs/source docs/build
+```
+
+9. Increase version number in `setup.cfg` file.
+10. Push all changes to the remote repository and create a merge request to `dev`.
+11. Make sure all tests succeed in the pipeline and merge.
+12. When enough changes accumulate, create a merge request to `main` once enough features
+    accumulated
+    to roll out a new version. Make again sure all test pipelines succeed.
+13. After merging to `main` a new version of the package is released to PyPi upon a successful
+    pipeline run.
+
+## Issues and new features
+
+Issues and new feature requests can be
+added [here](https://codebase.helmholtz.cloud/carl.meier/artof/-/issues).
+
+## Development version
+
+A version with features under development is available under the TestPyPi repository and can be
+installed as followed:
+
+```bash
+pip install --index-url https://test.pypi.org/simple/ artof
+```
+
+The documentation can be found [here](https://artof-42d889.pages.hzdr.de/dev/).

artof-1.1.0/README.md

@@ -0,0 +1,68 @@
+# artof
+
+The artof package is a jupyter notebook tool to read, process and analyze data collected from angle
+resolved time of flight (ARTOF) sensors.
+
+## Getting started
+
+To use this package python version >=3.10 is needed. The installation can be done using the command:
+
+```bash
+pip install artof
+```
+
+## Documentation
+
+The documentation can be found [here](https://artof-42d889.pages.hzdr.de/main/). It is automatically
+generated from the docstrings in all python classes.
+
+## Workflow
+
+The implementation of a new feature should be conducted as follows:
+
+1. Create a new branch with a sensible name as a fork from `dev`.
+2. Implement features including documentation.
+3. If required, make changes to the Sphinx documentation under `docs/source/`.
+4. Check if all existing tests are still working (cmd: `pytest`) and write new test functions.
+5. If there were changes to `dev` since the initial fork, merge it into your branch and resolve
+   conflicts. Check again if all tests are running.
+6. Make sure the pylint rating of each file is 8 or higher. To do so run
+
+```bash
+pylint src/artof/{file}
+```
+
+7. Update documentation in the `./docs` folder using `.rst` and `sphinx`. For automatic doc
+   generation use `.. automodule:: artof.{module}` or `.. autoclass:: artof.{module}.{class}`. Do
+   not forget to add new `.rst`-files to index.
+8. Test the doc generation and ensure there are no warnings (else the pipeline will fail). To do
+   so run
+
+```bash
+sphinx-build -M html docs/source docs/build
+```
+
+9. Increase version number in `setup.cfg` file.
+10. Push all changes to the remote repository and create a merge request to `dev`.
+11. Make sure all tests succeed in the pipeline and merge.
+12. When enough changes accumulate, create a merge request to `main` once enough features
+    accumulated
+    to roll out a new version. Make again sure all test pipelines succeed.
+13. After merging to `main` a new version of the package is released to PyPi upon a successful
+    pipeline run.
+
+## Issues and new features
+
+Issues and new feature requests can be
+added [here](https://codebase.helmholtz.cloud/carl.meier/artof/-/issues).
+
+## Development version
+
+A version with features under development is available under the TestPyPi repository and can be
+installed as followed:
+
+```bash
+pip install --index-url https://test.pypi.org/simple/ artof
+```
+
+The documentation can be found [here](https://artof-42d889.pages.hzdr.de/dev/).

artof-1.1.0/pyproject.toml

@@ -0,0 +1,5 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel>=0.37.0"]
+build-backend = "setuptools.build_meta"
+[tool.black]
+line-length = 100

artof-1.1.0/setup.cfg

@@ -0,0 +1,40 @@
+[metadata]
+name = artof
+version = 1.1.0
+author = Carl Magnus Meier
+author_email = magnus.meier@helmholtz-berlin.de
+description = The ARTOF is a tool to read, process and analyze data collected from angle resolved time of flight (ARToF) sensors of the PS-ISRR.
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://codebase.helmholtz.cloud/carl.meier/artof
+classifiers = 
+	Programming Language :: Python :: 3
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+
+[options]
+package_dir = 
+	= src
+include_package_data = True
+packages = find:
+python_requires = >=3.10
+install_requires = 
+	numpy
+	scipy
+	pandas
+	IPython
+	plotly
+	anywidget
+
+[options.packages.find]
+where = src
+
+[options.extras_require]
+dev = 
+	pytest
+	pytest-cov
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

artof-1.1.0/src/artof/__init__.py

@@ -0,0 +1,6 @@
+"""
+ARTOF: A Python package for loading and processing ARTOF data.
+"""
+
+from .artof_loader import ARTOFLoader
+from .live_loader import LiveLoader

artof-1.1.0/src/artof/artof_loader.py

@@ -0,0 +1,187 @@
+"""Module containing ARTOFLoader class for loading and processing artof data.
+
+The ARTOFLoader class is used to load and process artof data from a specified directory.
+"""
+
+import plotly.graph_objects as go
+from IPython.display import display
+
+from .base_loader import BaseLoader
+from .data_process import get_axis_values, project_data
+from .plotting import plot_1d, plot_2d, plot_counts
+
+
+class ARTOFLoader(BaseLoader):
+    """
+    Class for loading and processing artof data.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        transform_format: str,
+        x0: float = None,
+        y0: float = None,
+        t0: float = None,
+        sweep_type: str = "Sienta",
+    ):
+        """
+        Initialize ARTOFLoader class.
+
+        Args:
+            path: Path to run directory.
+            transform_format: Format to load data in ('raw', 'raw_SI', 'cylindrical', 'spherical').
+            x0: Offset for x ticks, optional (default extracted from acquisition.cfg).
+            y0: Offset for y ticks, optional (default extracted from acquisition.cfg).
+            t0: Offset for t ticks, optional (default extracted from acquisition.cfg).
+            sweep_type: Sweep type ('Sienta' or 'normal'), optional (default 'Sienta').
+        """
+        super().__init__(path, transform_format, x0, y0, t0, sweep_type)
+        self.fig = None
+
+    def transform_data(self, iter_interval: tuple = None, multithreading: bool = True):
+        """
+        Load artof data for run in directory and transform into desired format.
+
+        Args:
+            iter_interval: Tuple of start (including) and stop (excluding) lens iteration to load
+                (default None, load all).
+            multithreading: Use multithreading for data loading (default True).
+        """
+        if iter_interval:
+            self.set_iter_interval(iter_interval[0], iter_interval[1])
+        transformed_data = self.load_and_transform(multithreading)
+        self.add_transformed_data(transformed_data)
+
+        self.print_transform_stats()
+
+    def bin_data(
+        self, cust_bin_confs=None, norm_modes: list = None, win_config: tuple[int, int] = None
+    ):
+        """
+        Bin loaded data into 3D histogram.
+
+        Args:
+            cust_bin_confs: List of 3 custom binning configurations for the 3 parameters
+                [min, max, points]. F.e.: [[-1500, 1500, 101], [-1500, 1500, 101],
+                [12000, 18000, 201]]
+            norm_modes: Normalization mode for binned data ('iterations', 'dwell_time', 'sweep').
+                Default is None.
+                - `iterations`: Normalize data by number of iterations.
+                - `dwell_time`: Normalize data by dwell time.
+                - `sweep`: Normalize data by changing window size of sweep data.
+            win_config: Tuple of window size and step size for sweep data (default None, one window)
+                If the last window is smaller than the step size, it will be ignored.
+
+
+        Raises:
+            Exception: If data is not loaded before binning.
+        """
+        # reset binned data from previous binning
+        self.binned_data = {}
+
+        # set binning configurations
+        self.set_bin_configs(cust_bin_confs)
+
+        binned_data = self.bin(self.transformed_data, norm_modes, win_config=win_config)
+        self.add_binned_data(binned_data)
+
+        # print windows if win_config is given
+        if win_config is not None:
+            print(
+                f"The following {len(self.binned_data)} window(s) were"
+                f" created: {list(self.binned_data.keys())}"
+            )
+
+    def plot(
+        self,
+        proj_axes: list,
+        ranges=None,
+        norm_step_size: bool = False,
+        photon_energy: float = None,
+        width: int = 600,
+        height: int = 600,
+    ):
+        """
+        Plot loaded data as projection onto given axes. Projections are possible onto 1 or 2 axes.
+
+        Args:
+            proj_axes: List containing all axes onto which the projection is performed, e.g., [0,1].
+            ranges: List containing ranges for axes (e.g., [[50, 101], [0,50], None]), if None
+                entire range of axes is used (default entire range of each axis).
+            norm_step_size: Normalize data with step size before plotting (default False).
+            photon_energy: Photon energy to plot in binding energy, optional (default None).
+            width: Width of plot (default 600).
+            height: Height of plot (default 600).
+
+        Raises:
+            ValueError: An incorrect number of projection axes provided.
+        """
+
+        if self.bin_edges is None:
+            raise RuntimeError("Data not binned. Please bin data before plotting.")
+
+        if len(proj_axes) not in [1, 2]:
+            raise ValueError(f"A projection along {len(proj_axes)} axes is not possible.")
+
+        if ranges is None:
+            ranges = [None, None, None]
+
+        # concatenate all binned data into one array TODO show spectral evolution in plot
+        # data = np.sum(list(self.binned_data.values()), axis=0)
+
+        axes_values = get_axis_values(self.bin_edges, self.axes, proj_axes, photon_energy)
+        proj_data_wins = {}
+        for win_id, data in self.binned_data.items():
+            proj_data_wins[win_id] = project_data(
+                data, self.bin_edges, proj_axes, ranges, norm_step_size
+            )
+
+        self.fig = go.Figure(layout=go.Layout(width=width, height=height))
+
+        if len(proj_axes) == 2:  # plot data in 2D as heatmap
+            plot_2d(
+                self.fig,
+                proj_data_wins,
+                self.bin_edges[proj_axes[0]],
+                self.bin_edges[proj_axes[1]],
+                self.axes,
+                proj_axes,
+                photon_energy,
+                height,
+            )
+        elif len(proj_axes) == 1:  # plot data in 1D as line
+            plot_1d(
+                self.fig,
+                axes_values[0],
+                proj_data_wins,
+                self.axes,
+                proj_axes,
+                photon_energy,
+                height,
+            )
+
+        self.fig.show()
+
+    def load_counts(self):
+        """
+        Load counts of all measured events.
+        """
+        self.add_event_counts(self.count_events())
+
+    def plot_counts(self, iter_range: list = None, width: int = 600, height: int = 600):
+        """
+        Plot counts of all measured events over iterations in given range.
+
+        Args:
+            range: Range of iterations to plot (def+ault None, plot all).
+            width: Width of plot (default 600).
+            height: Height of plot (default 600).
+        """
+
+        iterations, counts = self.get_iter_counts(iter_range)
+
+        # create plot
+        self.fig = go.FigureWidget(layout=go.Layout(width=width, height=height))
+        display(self.fig)
+        plot_counts(self.fig, iterations, counts)

artof-1.1.0/src/artof/artof_utils.py

@@ -0,0 +1,58 @@
+"""
+The artof_utils module provide static utility functions to be used in the artof package.
+"""
+
+import os
+
+
+def get_next_step(it: int, step: int, lens_steps: int):
+    """
+    Get the next step of a run
+
+    Args:
+        it: Current iteration.
+        step: Current step.
+        lens_steps: Total number of steps per iteration.
+
+    Returns:
+        Next iteration and step
+    """
+
+    if step == lens_steps - 1:
+        return it + 1, 0
+    return it, step + 1
+
+
+def is_last_step(it: int, step: int, stop_iter: int, lens_steps: int):
+    """
+    Check if the current file is the last file of a run
+
+    Args:
+        it: Current iteration.
+        step: Current step in iteration.
+        lens_steps: Total number of steps.
+        stop_iter: Maximum number of iterations.
+
+    Returns:
+        Boolean value if the current file is the last file
+    """
+
+    return it == stop_iter - 1 and step == lens_steps - 1
+
+
+def next_file_exists(path: str, it: int, step: int, lens_steps: int):
+    """
+    Check if the next file of a run exists
+
+    Args:
+        path: Path where data files are located.
+        it: Current iteration.
+        step: Current step.
+        lens_steps: Total number of steps.
+
+    Returns:
+        Boolean value if the next file exists
+    """
+
+    next_step = get_next_step(it, step, lens_steps)
+    return os.path.exists(f"{path}/{next_step[0]}_{next_step[1]}")