enable tests

.clang-tidy

@@ -1,42 +0,0 @@
-
----
-Checks:          '*, 
-                    -altera-*,
-                    -android-cloexec-fopen,
-                    -cppcoreguidelines-pro-bounds-array-to-pointer-decay, 
-                    -cppcoreguidelines-pro-bounds-pointer-arithmetic, 
-                    -fuchsia*,
-                    -readability-else-after-return,
-                    -readability-avoid-const-params-in-decls,
-                    -readability-identifier-length,
-                    -cppcoreguidelines-pro-bounds-constant-array-index,
-                    -cppcoreguidelines-pro-type-reinterpret-cast,
-                    -llvm-header-guard,
-                    -modernize-use-nodiscard,
-                    -misc-non-private-member-variables-in-classes,
-                    -readability-static-accessed-through-instance,
-                    -readability-braces-around-statements,
-                    -readability-isolate-declaration,
-                    -readability-implicit-bool-conversion,
-                    -readability-identifier-length,
-                    -readability-identifier-naming,
-                    -hicpp-signed-bitwise,
-                    -hicpp-no-array-decay, 
-                    -hicpp-braces-around-statements,
-                    -google-runtime-references, 
-                    -google-readability-todo, 
-                    -google-readability-braces-around-statements,
-                    -modernize-use-trailing-return-type,
-                    -llvmlibc-*'
-
-HeaderFilterRegex: \.hpp
-FormatStyle:     none
-CheckOptions:
-  - { key: readability-identifier-naming.NamespaceCase,       value: lower_case }
- # - { key: readability-identifier-naming.FunctionCase,        value: lower_case }
-  - { key: readability-identifier-naming.ClassCase,           value: CamelCase  }
- # - { key: readability-identifier-naming.MethodCase,          value: CamelCase  }
- # - { key: readability-identifier-naming.StructCase,          value: CamelCase  }
- # - { key: readability-identifier-naming.VariableCase,        value: lower_case }
-  - { key: readability-identifier-naming.GlobalConstantCase,  value: UPPER_CASE }
-...

.gitea/workflows/cmake_build.yml

@@ -1,58 +0,0 @@
-name: Build the package using cmake then documentation
-
-on:
-  workflow_dispatch:
-
-    
-
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [ubuntu-latest, ] 
-        python-version: ["3.12", ] 
-
-    runs-on: ${{ matrix.platform }}
-
-
-    defaults:
-      run:
-        shell: "bash -l {0}"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup dev env
-        run: |
-            sudo apt-get update
-            sudo apt-get -y install cmake gcc g++
-
-      - name: Get conda
-        uses: conda-incubator/setup-miniconda@v3
-        with:
-          python-version: ${{ matrix.python-version }}
-          environment-file: etc/dev-env.yml
-          miniforge-version: latest
-          channels: conda-forge
-          conda-remove-defaults: "true"
-
-      - name: Build library 
-        run: |
-            mkdir build 
-            cd build 
-            cmake .. -DAARE_SYSTEM_LIBRARIES=ON -DAARE_DOCS=ON 
-            make -j 2 
-            make docs
-
-
-
-
-
-
-

.gitea/workflows/rh8-native.yml

@@ -1,36 +0,0 @@
-name: Build on RHEL8
-
-on:
-  push:
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: "ubuntu-latest"
-    container:
-      image: gitea.psi.ch/images/rhel8-developer-gitea-actions
-    steps:
-      # workaround until actions/checkout@v4 is available for RH8
-      # - uses: actions/checkout@v4
-      - name: Clone repository
-        run: |
-          echo Cloning ${{ github.ref_name }}
-          git clone https://${{secrets.GITHUB_TOKEN}}@gitea.psi.ch/${{ github.repository }}.git --branch=${{ github.ref_name }} .
-
-
-      - name: Install dependencies
-        run: |
-          dnf install -y cmake python3.12 python3.12-devel python3.12-pip
-
-      - name: Build library 
-        run: |
-            mkdir build && cd build
-            cmake .. -DAARE_PYTHON_BINDINGS=ON -DAARE_TESTS=ON -DPython_FIND_VIRTUALENV=FIRST
-            make -j 2 
-
-      - name: C++ unit tests
-        working-directory: ${{gitea.workspace}}/build
-        run: ctest

.gitea/workflows/rh9-native.yml

@@ -1,31 +0,0 @@
-name: Build on RHEL9
-
-on:
-  push:
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: "ubuntu-latest"
-    container:
-      image: gitea.psi.ch/images/rhel9-developer-gitea-actions
-    steps:
-      - uses: actions/checkout@v4
-
-
-      - name: Install dependencies
-        run: |
-          dnf install -y cmake python3.12 python3.12-devel python3.12-pip
-
-      - name: Build library 
-        run: |
-            mkdir build && cd build
-            cmake .. -DAARE_PYTHON_BINDINGS=ON -DAARE_TESTS=ON
-            make -j 2 
-
-      - name: C++ unit tests
-        working-directory: ${{gitea.workspace}}/build
-        run: ctest

.github/workflows/build_conda.yml

@@ -1,40 +0,0 @@
-name: Build pkgs and deploy if on main
-
-on:
-  push:
-    branches:
-     - developer
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [ubuntu-latest, ] # macos-12, windows-2019]
-        python-version: ["3.12",]
-
-    runs-on: ${{ matrix.platform }}
-
-    # The setup-miniconda action needs this to activate miniconda
-    defaults:
-      run:
-        shell: "bash -l {0}"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Get conda
-        uses: conda-incubator/setup-miniconda@v3.0.4
-        with:
-          python-version: ${{ matrix.python-version }}
-          channels: conda-forge
-
-      - name: Prepare
-        run: conda install conda-build=24.9 conda-verify pytest anaconda-client
-
-      - name: Disable upload
-        run: conda config --set anaconda_upload no
-
-      - name: Build
-        run: conda build conda-recipe 
-

.github/workflows/build_docs.yml

@@ -1,10 +1,11 @@
-name: Build the package using cmake then documentation
+name: Build package and docs, test, deploy if on main
 
 on:
   workflow_dispatch:
   push:
     
 
+
 permissions:
   contents: read
   pages: write
@@ -15,11 +16,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        platform: [ubuntu-latest, ] 
+        platform: [ubuntu-latest, ] # macos-12, windows-2019]
         python-version: ["3.12",]
 
     runs-on: ${{ matrix.platform }}
 
+    # The setup-miniconda action needs this to activate miniconda
     defaults:
       run:
         shell: "bash -l {0}"
@@ -28,22 +30,28 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Get conda
-        uses: conda-incubator/setup-miniconda@v3
+        uses: conda-incubator/setup-miniconda@v3.0.4
         with:
           python-version: ${{ matrix.python-version }}
-          environment-file: etc/dev-env.yml
-          miniforge-version: latest
           channels: conda-forge
-          conda-remove-defaults: "true"
 
-      - name: Build library 
+      - name: Prepare
+        run: conda install doxygen sphinx=7.1.2 breathe pybind11 sphinx_rtd_theme furo nlohmann_json zeromq fmt numpy catch2
+
+      - name: Build 
         run: |
             mkdir build 
             cd build 
-            cmake .. -DAARE_SYSTEM_LIBRARIES=ON -DAARE_DOCS=ON 
+            cmake .. -DAARE_SYSTEM_LIBRARIES=ON -DAARE_TESTS=ON -DAARE_DOCS=ON 
             make -j 2 
             make docs
 
+      - name: Test
+        working-directory: ${{github.workspace}}/build
+        # Execute tests defined by the CMake configuration.
+        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+        run: ctest -C ${{env.BUILD_TYPE}} -j1
+
       - name: Upload static files as artifact
         id: deployment
         uses: actions/upload-pages-artifact@v3 

.github/workflows/build_wheel.yml

@@ -1,64 +0,0 @@
-name: Build wheel
-
-on:
-    workflow_dispatch:
-    pull_request:
-    push:
-      branches:
-        - main
-    release:
-      types:
-        - published
-  
-
-jobs:
-  build_wheels:
-    name: Build wheels on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest,]
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Build wheels
-        run: pipx run cibuildwheel==2.23.0
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
-          path: ./wheelhouse/*.whl
-    
-  build_sdist:
-    name: Build source distribution
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Build sdist
-      run: pipx run build --sdist
-
-    - uses: actions/upload-artifact@v4
-      with:
-        name: cibw-sdist
-        path: dist/*.tar.gz
-
-  upload_pypi:
-    needs: [build_wheels, build_sdist]
-    runs-on: ubuntu-latest
-    environment: pypi
-    permissions:
-        id-token: write
-    if: github.event_name == 'release' && github.event.action == 'published'
-    # or, alternatively, upload to PyPI on every tag starting with 'v' (remove on: release above to use this)
-    # if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
-    steps:
-        - uses: actions/download-artifact@v4
-          with:
-            # unpacks all CIBW artifacts into dist/
-            pattern: cibw-*
-            path: dist
-            merge-multiple: true
-
-        - uses: pypa/gh-action-pypi-publish@release/v1

.github/workflows/deploy.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
      - main
+     - developer
 
 jobs:
   build:
@@ -33,6 +34,7 @@ jobs:
         run: conda install conda-build=24.9 conda-verify pytest anaconda-client
 
       - name: Enable upload
+        if: github.ref == 'refs/heads/main'
         run: conda config --set anaconda_upload yes
 
       - name: Build

.gitignore

@@ -17,8 +17,7 @@ Testing/
 ctbDict.cpp
 ctbDict.h
 
-wheelhouse/
-dist/
+
 
 *.pyc
 */__pycache__/*

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.14)
 
 project(aare 
     VERSION 1.0.0
@@ -11,14 +11,6 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-execute_process(
-        COMMAND git log -1 --format=%h
-        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
-        OUTPUT_VARIABLE GIT_HASH
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-        )
-message(STATUS "Building from git hash: ${GIT_HASH}")
-
 if (${CMAKE_VERSION} VERSION_GREATER "3.24")
     cmake_policy(SET CMP0135 NEW) #Fetch content download timestamp
 endif()
@@ -48,7 +40,7 @@ option(AARE_DOCS "Build documentation" OFF)
 option(AARE_VERBOSE "Verbose output" OFF)
 option(AARE_CUSTOM_ASSERT "Use custom assert" OFF)
 option(AARE_INSTALL_PYTHONEXT "Install the python extension in the install tree under CMAKE_INSTALL_PREFIX/aare/" OFF)
-option(AARE_ASAN "Enable AddressSanitizer" OFF)
+
 
 # Configure which of the dependencies to use FetchContent for
 option(AARE_FETCH_FMT "Use FetchContent to download fmt" ON)
@@ -56,7 +48,6 @@ option(AARE_FETCH_PYBIND11 "Use FetchContent to download pybind11" ON)
 option(AARE_FETCH_CATCH "Use FetchContent to download catch2" ON)
 option(AARE_FETCH_JSON "Use FetchContent to download nlohmann::json" ON)
 option(AARE_FETCH_ZMQ "Use FetchContent to download libzmq" ON)
-option(AARE_FETCH_LMFIT "Use FetchContent to download lmfit" ON)
 
 
 #Convenience option to use system libraries only (no FetchContent)
@@ -68,8 +59,6 @@ if(AARE_SYSTEM_LIBRARIES)
     set(AARE_FETCH_CATCH OFF CACHE BOOL "Disabled FetchContent for catch2" FORCE)
     set(AARE_FETCH_JSON OFF CACHE BOOL "Disabled FetchContent for nlohmann::json" FORCE)
     set(AARE_FETCH_ZMQ OFF CACHE BOOL "Disabled FetchContent for libzmq" FORCE)
-    # Still fetch lmfit when setting AARE_SYSTEM_LIBRARIES since this is not available
-    # on conda-forge
 endif()
 
 if(AARE_VERBOSE)
@@ -87,67 +76,16 @@ endif()
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-if(AARE_FETCH_LMFIT)
-    #TODO! Should we fetch lmfit from the web or inlcude a tar.gz in the repo?
-    set(LMFIT_PATCH_COMMAND git apply ${CMAKE_CURRENT_SOURCE_DIR}/patches/lmfit.patch)
-
-    # For cmake < 3.28 we can't supply EXCLUDE_FROM_ALL to FetchContent_Declare
-    # so we need this workaround
-    if (${CMAKE_VERSION} VERSION_LESS "3.28")
-        FetchContent_Declare(
-            lmfit
-            GIT_REPOSITORY https://jugit.fz-juelich.de/mlz/lmfit.git
-            GIT_TAG        main
-            PATCH_COMMAND ${LMFIT_PATCH_COMMAND}
-            UPDATE_DISCONNECTED 1
-        )
-    else()
-        FetchContent_Declare(
-            lmfit
-            GIT_REPOSITORY https://jugit.fz-juelich.de/mlz/lmfit.git
-            GIT_TAG        main
-            PATCH_COMMAND ${LMFIT_PATCH_COMMAND}
-            UPDATE_DISCONNECTED 1
-            EXCLUDE_FROM_ALL 1
-        )
-    endif()
-    
-
-    #Disable what we don't need from lmfit
-    set(BUILD_TESTING OFF CACHE BOOL "")
-    set(LMFIT_CPPTEST OFF CACHE BOOL "")
-    set(LIB_MAN OFF CACHE BOOL "")
-    set(LMFIT_CPPTEST OFF CACHE BOOL "")
-    set(BUILD_SHARED_LIBS OFF CACHE BOOL "")
-
-    if (${CMAKE_VERSION} VERSION_LESS "3.28")
-        if(NOT lmfit_POPULATED)
-            FetchContent_Populate(lmfit)
-            add_subdirectory(${lmfit_SOURCE_DIR} ${lmfit_BINARY_DIR} EXCLUDE_FROM_ALL)
-        endif()
-    else()
-        FetchContent_MakeAvailable(lmfit)
-    endif()
-    
-    set_property(TARGET lmfit PROPERTY POSITION_INDEPENDENT_CODE ON)
-else()
-    find_package(lmfit REQUIRED)
-endif()
-
-
 if(AARE_FETCH_ZMQ)
     # Fetchcontent_Declare is deprecated need to find a way to update this
     # for now setting the policy to old is enough
     if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.30")
         cmake_policy(SET CMP0169 OLD)
     endif()
-    set(ZMQ_PATCH_COMMAND git apply ${CMAKE_CURRENT_SOURCE_DIR}/patches/libzmq_cmake_version.patch)
     FetchContent_Declare(
         libzmq
         GIT_REPOSITORY https://github.com/zeromq/libzmq.git
         GIT_TAG        v4.3.4
-        PATCH_COMMAND ${ZMQ_PATCH_COMMAND}
-        UPDATE_DISCONNECTED 1
     )
     # Disable unwanted options from libzmq
     set(BUILD_TESTS OFF CACHE BOOL "Switch off libzmq test build")
@@ -189,8 +127,8 @@ if (AARE_FETCH_FMT)
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}   
-    )  
+        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
 else()
       find_package(fmt 6 REQUIRED)
 endif()
@@ -208,6 +146,7 @@ if (AARE_FETCH_JSON)
     install(
         TARGETS nlohmann_json
         EXPORT "${TARGETS_EXPORT_NAME}"
+        
     )
     message(STATUS "target: ${NLOHMANN_JSON_TARGET_NAME}")
 else()
@@ -286,6 +225,13 @@ if(CMAKE_BUILD_TYPE STREQUAL "Release")
     target_compile_options(aare_compiler_flags INTERFACE -O3)
 else()
     message(STATUS "Debug build")
+    target_compile_options(
+        aare_compiler_flags 
+        INTERFACE 
+            -Og 
+            -ggdb3 
+    )
+
 endif()
 
 # Common flags for GCC and Clang
@@ -310,21 +256,7 @@ target_compile_options(
 endif() #GCC/Clang specific
 
 
-if(AARE_ASAN)
-    message(STATUS "AddressSanitizer enabled")
-    target_compile_options(
-        aare_compiler_flags 
-        INTERFACE 
-            -fsanitize=address,undefined,pointer-compare 
-            -fno-omit-frame-pointer
-    )
-    target_link_libraries(
-        aare_compiler_flags 
-        INTERFACE 
-            -fsanitize=address,undefined,pointer-compare 
-            -fno-omit-frame-pointer
-    )
-endif()
+
 
 
 
@@ -343,17 +275,11 @@ set(PUBLICHEADERS
     include/aare/ClusterFinder.hpp
     include/aare/ClusterFile.hpp
     include/aare/CtbRawFile.hpp
-    include/aare/ClusterVector.hpp
-    include/aare/decode.hpp
     include/aare/defs.hpp
     include/aare/Dtype.hpp
     include/aare/File.hpp
-    include/aare/Fit.hpp
     include/aare/FileInterface.hpp
-    include/aare/FilePtr.hpp
     include/aare/Frame.hpp
-    include/aare/geo_helpers.hpp
-    include/aare/JungfrauDataFile.hpp
     include/aare/NDArray.hpp
     include/aare/NDView.hpp
     include/aare/NumpyFile.hpp
@@ -364,7 +290,6 @@ set(PUBLICHEADERS
     include/aare/RawMasterFile.hpp
     include/aare/RawSubFile.hpp
     include/aare/VarClusterFinder.hpp
-    include/aare/utils/task.hpp
 
 )
 
@@ -374,23 +299,14 @@ set(SourceFiles
     ${CMAKE_CURRENT_SOURCE_DIR}/src/ClusterFile.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/defs.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/Dtype.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/decode.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/Frame.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/File.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/FilePtr.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/Fit.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/geo_helpers.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/JungfrauDataFile.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/NumpyFile.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/NumpyHelpers.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/Interpolator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/PixelMap.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/RawFile.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/RawSubFile.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/RawMasterFile.cpp
-
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/task.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/ifstream_helpers.cpp
 )
 
 
@@ -400,8 +316,6 @@ target_include_directories(aare_core PUBLIC
     "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
 )
 
-
-
 target_link_libraries(
     aare_core 
     PUBLIC 
@@ -410,8 +324,6 @@ target_link_libraries(
     ${STD_FS_LIB} # from helpers.cmake
     PRIVATE 
     aare_compiler_flags 
-    "$<BUILD_INTERFACE:lmfit>"
-
 )
 
 set_target_properties(aare_core PROPERTIES
@@ -425,24 +337,17 @@ endif()
 
 if(AARE_TESTS)
     set(TestSources
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/algorithm.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/defs.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/decode.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/Dtype.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/Frame.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/geo_helpers.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/RawMasterFile.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/NDArray.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/NDView.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/ClusterFinder.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/ClusterVector.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/ClusterFile.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/Pedestal.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/JungfrauDataFile.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/NumpyFile.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/NumpyHelpers.test.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/src/RawFile.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/task.test.cpp
 
         )
     target_sources(tests PRIVATE ${TestSources} )
@@ -520,4 +425,4 @@ if(AARE_MASTER_PROJECT)
     set(CMAKE_INSTALL_DIR "share/cmake/${PROJECT_NAME}")
     set(PROJECT_LIBRARIES aare-core aare-compiler-flags )
     include(cmake/package_config.cmake)
-endif()
+endif()

conda-recipe/meta.yaml

@@ -1,10 +1,6 @@
 package:
   name: aare
-  version: 2025.4.22 #TODO! how to not duplicate this?
-
-
-
-
+  version: 2024.11.28.dev0 #TODO! how to not duplicate this?
 
 
 source:
@@ -39,7 +35,6 @@ requirements:
   run:
     - python {{python}}
     - numpy {{ numpy }}
-    - matplotlib
 
 
 test:

docs/CMakeLists.txt

@@ -12,7 +12,28 @@ set(SPHINX_BUILD ${CMAKE_CURRENT_BINARY_DIR})
 
 
 file(GLOB SPHINX_SOURCE_FILES CONFIGURE_DEPENDS "src/*.rst")
-
+# set(SPHINX_SOURCE_FILES
+#   src/index.rst
+#   src/Installation.rst
+#   src/Requirements.rst
+#   src/NDArray.rst
+#   src/NDView.rst
+#   src/File.rst
+#   src/Frame.rst
+#   src/Dtype.rst
+#   src/ClusterFinder.rst
+#   src/ClusterFile.rst
+#   src/Pedestal.rst
+#   src/RawFile.rst
+#   src/RawSubFile.rst
+#   src/RawMasterFile.rst
+#   src/VarClusterFinder.rst
+#   src/pyVarClusterFinder.rst
+#   src/pyFile.rst
+#   src/pyCtbRawFile.rst
+#   src/pyRawFile.rst
+#   src/pyRawMasterFile.rst
+# )
 
 
 foreach(filename ${SPHINX_SOURCE_FILES})

docs/conf.py.in

@@ -29,6 +29,7 @@ version = '@PROJECT_VERSION@'
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = ['breathe',
+              'sphinx_rtd_theme',
               'sphinx.ext.autodoc',
               'sphinx.ext.napoleon',
              ]

docs/src/ClusterFinderMT.rst

@@ -1,7 +0,0 @@
-ClusterFinderMT
-==================
-
-
-.. doxygenclass:: aare::ClusterFinderMT
-   :members:
-   :undoc-members:

docs/src/ClusterVector.rst

@@ -1,6 +0,0 @@
-ClusterVector
-=============
-
-.. doxygenclass:: aare::ClusterVector
-   :members:
-   :undoc-members:

docs/src/JungfrauDataFile.rst

@@ -1,25 +0,0 @@
-JungfrauDataFile
-==================
-
-JungfrauDataFile is a class to read the .dat files that are produced by Aldo's receiver. 
-It is mostly used for calibration. 
-
-The structure of the file is:
-
-* JungfrauDataHeader
-* Binary data (256x256, 256x1024 or 512x1024)
-* JungfrauDataHeader
-* ...
-
-There is no metadata indicating number of frames or the size of the image, but this
-will be infered by this reader. 
-
-.. doxygenstruct:: aare::JungfrauDataHeader
-   :members:
-   :undoc-members:
-   :private-members:
-
-.. doxygenclass:: aare::JungfrauDataFile
-   :members:
-   :undoc-members:
-   :private-members:

docs/src/Tests.rst

@@ -1,47 +0,0 @@
-****************
-Tests
-****************
-
-We test the code both from the C++ and Python API. By default only tests that does not require image data is run. 
-
-C++
-~~~~~~~~~~~~~~~~~~
-
-.. code-block:: bash
-
-    mkdir build
-    cd build
-    cmake .. -DAARE_TESTS=ON
-    make -j 4
-
-    export AARE_TEST_DATA=/path/to/test/data
-    ./run_test [.files] #or using ctest, [.files] is the option to include tests needing data
-
-
-
-Python
-~~~~~~~~~~~~~~~~~~
-
-.. code-block:: bash
-
-    #From the root dir of the library
-    python -m pytest python/tests --files # passing --files will run the tests needing data
-
-
-
-Getting the test data
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. attention ::
-
-    The tests needing the test data are not run by default. To make the data available, you need to set the environment variable
-    AARE_TEST_DATA to the path of the test data directory. Then pass either [.files] for the C++ tests or --files for Python
-
-The image files needed for the test are large and are not included in the repository. They are stored
-using GIT LFS in a separate repository. To get the test data, you need to clone the repository.
-To do this, you need to have GIT LFS installed. You can find instructions on how to install it here: https://git-lfs.github.com/
-Once you have GIT LFS installed, you can clone the repository like any normal repo using:
-
-.. code-block:: bash
-    
-    git clone https://gitea.psi.ch/detectors/aare-test-data.git

docs/src/algorithm.rst

@@ -1,5 +0,0 @@
-algorithm
-=============
-
-.. doxygenfile:: algorithm.hpp
-

docs/src/index.rst

@@ -20,6 +20,9 @@ AARE
     Requirements
     Consume
 
+
+
+
 .. toctree::
     :caption: Python API
     :maxdepth: 1
@@ -27,30 +30,22 @@ AARE
     pyFile
     pyCtbRawFile
     pyClusterFile
-    pyClusterVector
-    pyJungfrauDataFile
     pyRawFile
     pyRawMasterFile
     pyVarClusterFinder
 
-    pyFit
-
 
 .. toctree::
     :caption: C++ API
     :maxdepth: 1
     
-    algorithm
     NDArray
     NDView
     Frame
     File
     Dtype
     ClusterFinder
-    ClusterFinderMT
     ClusterFile
-    ClusterVector
-    JungfrauDataFile
     Pedestal
     RawFile
     RawSubFile
@@ -59,8 +54,4 @@ AARE
 
 
 
-.. toctree::
-    :caption: Developer
-    :maxdepth: 3
-    
-    Tests
+

docs/src/pyClusterVector.rst

@@ -1,33 +0,0 @@
-ClusterVector
-================
-
-The ClusterVector, holds clusters from the ClusterFinder. Since it is templated
-in C++  we use a suffix indicating the data type in python. The suffix is
-``_i`` for integer, ``_f`` for float, and ``_d`` for double.
-
-At the moment the functionality from python is limited and it is not supported
-to push_back clusters to the vector. The intended use case is to pass it to 
-C++ functions that support the ClusterVector or to view it as a numpy array.
-
-**View ClusterVector as numpy array**
-
-.. code:: python
-
-    from aare import ClusterFile
-    with ClusterFile("path/to/file") as f:
-        cluster_vector = f.read_frame()
-
-    # Create a copy of the cluster data in a numpy array
-    clusters = np.array(cluster_vector)
-
-    # Avoid copying the data by passing copy=False
-    clusters = np.array(cluster_vector, copy = False)
-
-
-.. py:currentmodule:: aare
-
-.. autoclass:: ClusterVector_i
-    :members:
-    :undoc-members:
-    :show-inheritance:
-    :inherited-members:

docs/src/pyFit.rst

@@ -1,19 +0,0 @@
-
-Fit
-========
-
-.. py:currentmodule:: aare
-
-
-**Functions**
-
-.. autofunction:: gaus
-
-.. autofunction:: pol1
-
-
-**Fitting**
-
-.. autofunction:: fit_gaus
-
-.. autofunction:: fit_pol1

docs/src/pyJungfrauDataFile.rst

@@ -1,10 +0,0 @@
-JungfrauDataFile
-===================
-
-.. py:currentmodule:: aare
-
-.. autoclass:: JungfrauDataFile
-    :members:
-    :undoc-members:
-    :show-inheritance:
-    :inherited-members:

etc/dev-env.yml

@@ -1,15 +0,0 @@
-name: dev-environment
-channels:
-  - conda-forge
-dependencies:
-  - anaconda-client
-  - doxygen 
-  - sphinx=7.1.2 
-  - breathe 
-  - pybind11 
-  - sphinx_rtd_theme 
-  - furo 
-  - nlohmann_json 
-  - zeromq 
-  - fmt 
-  - numpy

include/aare/CircularFifo.hpp

@@ -1,97 +0,0 @@
-#pragma once
-
-#include <chrono>
-#include <fmt/color.h>
-#include <fmt/format.h>
-#include <memory>
-#include <thread>
-
-#include "aare/ProducerConsumerQueue.hpp"
-
-namespace aare {
-
-template <class ItemType> class CircularFifo {
-    uint32_t fifo_size;
-    aare::ProducerConsumerQueue<ItemType> free_slots;
-    aare::ProducerConsumerQueue<ItemType> filled_slots;
-
-  public:
-    CircularFifo() : CircularFifo(100){};
-    CircularFifo(uint32_t size) : fifo_size(size), free_slots(size + 1), filled_slots(size + 1) {
-
-        // TODO! how do we deal with alignment for writing? alignas???
-        // Do we give the user a chance to provide memory locations?
-        // Templated allocator?
-        for (size_t i = 0; i < fifo_size; ++i) {
-            free_slots.write(ItemType{});
-        }
-    }
-
-    bool next() {
-        // TODO! avoid default constructing ItemType
-        ItemType it;
-        if (!filled_slots.read(it))
-            return false;
-        if (!free_slots.write(std::move(it)))
-            return false;
-        return true;
-    }
-
-    ~CircularFifo() {}
-
-    using value_type = ItemType;
-
-    auto numFilledSlots() const noexcept { return filled_slots.sizeGuess(); }
-    auto numFreeSlots() const noexcept { return free_slots.sizeGuess(); }
-    auto isFull() const noexcept { return filled_slots.isFull(); }
-
-    ItemType pop_free() {
-        ItemType v;
-        while (!free_slots.read(v))
-            ;
-        return std::move(v);
-        // return v;
-    }
-
-    bool try_pop_free(ItemType &v) { return free_slots.read(v); }
-
-    ItemType pop_value(std::chrono::nanoseconds wait, std::atomic<bool> &stopped) {
-        ItemType v;
-        while (!filled_slots.read(v) && !stopped) {
-            std::this_thread::sleep_for(wait);
-        }
-        return std::move(v);
-    }
-
-    ItemType pop_value() {
-        ItemType v;
-        while (!filled_slots.read(v))
-            ;
-        return std::move(v);
-    }
-
-    ItemType *frontPtr() { return filled_slots.frontPtr(); }
-
-    // TODO! Add function to move item from filled to free to be used
-    // with the frontPtr function
-
-    template <class... Args> void push_value(Args &&...recordArgs) {
-        while (!filled_slots.write(std::forward<Args>(recordArgs)...))
-            ;
-    }
-
-    template <class... Args> bool try_push_value(Args &&...recordArgs) {
-        return filled_slots.write(std::forward<Args>(recordArgs)...);
-    }
-
-    template <class... Args> void push_free(Args &&...recordArgs) {
-        while (!free_slots.write(std::forward<Args>(recordArgs)...))
-            ;
-    }
-
-    template <class... Args> bool try_push_free(Args &&...recordArgs) {
-        return free_slots.write(std::forward<Args>(recordArgs)...);
-    }
-};
-
-} // namespace aare

include/aare/Cluster.hpp

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <numeric>
-
-namespace aare {
-
-//TODO! Template this? 
-struct Cluster3x3 {
-    int16_t x;
-    int16_t y;
-    int32_t data[9];
-
-    int32_t sum_2x2() const{
-        std::array<int32_t, 4> total;
-        total[0] = data[0] + data[1] + data[3] + data[4];
-        total[1] = data[1] + data[2] + data[4] + data[5];
-        total[2] = data[3] + data[4] + data[6] + data[7];
-        total[3] = data[4] + data[5] + data[7] + data[8];
-        return *std::max_element(total.begin(), total.end());
-    }
-
-    int32_t sum() const{
-        return std::accumulate(data, data + 9, 0);
-    }
-};
-struct Cluster2x2 {
-    int16_t x;
-    int16_t y;
-    int32_t data[4];
-};
-
-} // namespace aare

include/aare/ClusterCollector.hpp

@@ -1,52 +0,0 @@
-#pragma once
-#include <atomic>
-#include <thread>
-
-#include "aare/ProducerConsumerQueue.hpp"
-#include "aare/ClusterVector.hpp"
-#include "aare/ClusterFinderMT.hpp"
-
-namespace aare {
-
-class ClusterCollector{
-        ProducerConsumerQueue<ClusterVector<int>>* m_source;
-        std::atomic<bool> m_stop_requested{false};
-        std::atomic<bool> m_stopped{true};
-        std::chrono::milliseconds m_default_wait{1};
-        std::thread m_thread;
-        std::vector<ClusterVector<int>> m_clusters;
-
-    void process(){
-        m_stopped = false;
-        fmt::print("ClusterCollector started\n");
-        while (!m_stop_requested || !m_source->isEmpty()) { 
-            if (ClusterVector<int> *clusters = m_source->frontPtr();
-                clusters != nullptr) {
-                m_clusters.push_back(std::move(*clusters));
-                m_source->popFront();
-            }else{
-                std::this_thread::sleep_for(m_default_wait);
-            }
-        }
-        fmt::print("ClusterCollector stopped\n");
-        m_stopped = true;
-    }
-
-    public:
-        ClusterCollector(ClusterFinderMT<uint16_t, double, int32_t>* source){
-            m_source = source->sink();
-            m_thread = std::thread(&ClusterCollector::process, this);
-        }
-        void stop(){
-            m_stop_requested = true;
-            m_thread.join();
-        }
-        std::vector<ClusterVector<int>> steal_clusters(){
-            if(!m_stopped){
-                throw std::runtime_error("ClusterCollector is still running");
-            }
-            return std::move(m_clusters);
-        }
-};
-
-} // namespace aare

include/aare/ClusterFile.hpp

@@ -1,17 +1,17 @@
-#pragma once
 
-#include "aare/Cluster.hpp"
-#include "aare/ClusterVector.hpp"
-#include "aare/NDArray.hpp"
+
 #include "aare/defs.hpp"
 #include <filesystem>
 #include <fstream>
-#include <optional>
 
 namespace aare {
 
+struct Cluster {
+    int16_t x;
+    int16_t y;
+    int32_t data[9];
+};
 
-//TODO! Legacy enums, migrate to enum class
 typedef enum {
     cBottomLeft = 0,
     cBottomRight = 1,
@@ -31,13 +31,6 @@ typedef enum {
     pTopRight = 8
 } pixel;
 
-struct Eta2 {
-    double x;
-    double y;
-    corner c;
-    int32_t sum;
-};
-
 struct ClusterAnalysis {
     uint32_t c;
     int32_t tot;
@@ -47,106 +40,28 @@ struct ClusterAnalysis {
 
 
 
-/**
- * @brief Class to read and write cluster files
- * Expects data to be laid out as:
- *
- *
- *       int32_t frame_number
- *       uint32_t number_of_clusters
- *       int16_t x, int16_t y, int32_t data[9] * number_of_clusters
- *       int32_t frame_number
- *       uint32_t number_of_clusters
- *       etc.
- */
 class ClusterFile {
     FILE *fp{};
-    uint32_t m_num_left{};            /*Number of photons left in frame*/
-    size_t m_chunk_size{};            /*Number of clusters to read at a time*/
-    const std::string m_mode;         /*Mode to open the file in*/
-    std::optional<ROI> m_roi;         /*Region of interest, will be applied if set*/
-    std::optional<NDArray<int32_t, 2>> m_noise_map; /*Noise map to cut photons, will be applied if set*/
-    std::optional<NDArray<double, 2>> m_gain_map; /*Gain map to apply to the clusters, will be applied if set*/
+    uint32_t m_num_left{};
+    size_t m_chunk_size{};
 
   public:
-    /**
-     * @brief Construct a new Cluster File object
-     * @param fname path to the file
-     * @param chunk_size number of clusters to read at a time when iterating
-     * over the file
-     * @param mode mode to open the file in. "r" for reading, "w" for writing,
-     * "a" for appending
-     * @throws std::runtime_error if the file could not be opened
-     */
-    ClusterFile(const std::filesystem::path &fname, size_t chunk_size = 1000,
-                const std::string &mode = "r");
-    
-    
+    ClusterFile(const std::filesystem::path &fname, size_t chunk_size = 1000);
     ~ClusterFile();
+    std::vector<Cluster> read_clusters(size_t n_clusters);
+    std::vector<Cluster> read_frame(int32_t &out_fnum);
+    std::vector<Cluster>
+    read_cluster_with_cut(size_t n_clusters, double *noise_map, int nx, int ny);
 
-    /**
-     * @brief Read n_clusters clusters from the file discarding frame numbers.
-     * If EOF is reached the returned vector will have less than n_clusters
-     * clusters
-     */
-    ClusterVector<int32_t> read_clusters(size_t n_clusters);
+    int analyze_data(int32_t *data, int32_t *t2, int32_t *t3, char *quad,
+                 double *eta2x, double *eta2y, double *eta3x, double *eta3y);
+    int analyze_cluster(Cluster cl, int32_t *t2, int32_t *t3, char *quad,
+                    double *eta2x, double *eta2y, double *eta3x,
+                    double *eta3y);
 
-    ClusterVector<int32_t> read_clusters(size_t n_clusters, ROI roi);
-
-    /**
-     * @brief Read a single frame from the file and return the clusters. The
-     * cluster vector will have the frame number set.
-     * @throws std::runtime_error if the file is not opened for reading or the file pointer not
-     * at the beginning of a frame
-     */
-    ClusterVector<int32_t> read_frame();
-
-
-    void write_frame(const ClusterVector<int32_t> &clusters);
-    
-    /**
-     * @brief Return the chunk size
-     */
     size_t chunk_size() const { return m_chunk_size; }
-
-    /**
-     * @brief Set the region of interest to use when reading clusters. If set only clusters within
-     * the ROI will be read.
-     */
-    void set_roi(ROI roi);
-
-    /**
-     * @brief Set the noise map to use when reading clusters. If set clusters below the noise
-     * level will be discarded. Selection criteria one of: Central pixel above noise, highest
-     * 2x2 sum above 2 * noise, total sum above 3 * noise.
-     */
-    void set_noise_map(const NDView<int32_t, 2> noise_map);
-
-    /**
-     * @brief Set the gain map to use when reading clusters. If set the gain map will be applied
-     * to the clusters that pass ROI and noise_map selection. The gain map is expected to be in ADU/energy.
-     */
-    void set_gain_map(const NDView<double, 2> gain_map);
-    
-    
-    /**
-     * @brief Close the file. If not closed the file will be closed in the destructor
-     */
     void close();
 
-    private:
-        ClusterVector<int32_t> read_clusters_with_cut(size_t n_clusters);
-        ClusterVector<int32_t> read_clusters_without_cut(size_t n_clusters);
-        ClusterVector<int32_t> read_frame_with_cut();
-        ClusterVector<int32_t> read_frame_without_cut();
-        bool is_selected(Cluster3x3 &cl);
-        Cluster3x3 read_one_cluster();
 };
 
-//TODO! helper functions that doesn't really belong here
-NDArray<double, 2> calculate_eta2(ClusterVector<int> &clusters);
-Eta2 calculate_eta2(Cluster3x3 &cl);
-Eta2 calculate_eta2(Cluster2x2 &cl);
-
-
 } // namespace aare

include/aare/ClusterFileSink.hpp

@@ -1,56 +0,0 @@
-#pragma once
-#include <atomic>
-#include <filesystem>
-#include <thread>
-
-#include "aare/ProducerConsumerQueue.hpp"
-#include "aare/ClusterVector.hpp"
-#include "aare/ClusterFinderMT.hpp"
-
-namespace aare{
-
-class ClusterFileSink{
-    ProducerConsumerQueue<ClusterVector<int>>* m_source;
-    std::atomic<bool> m_stop_requested{false};
-    std::atomic<bool> m_stopped{true};
-    std::chrono::milliseconds m_default_wait{1};
-    std::thread m_thread;
-    std::ofstream m_file;
-
-
-    void process(){
-        m_stopped = false;
-        fmt::print("ClusterFileSink started\n");
-        while (!m_stop_requested || !m_source->isEmpty()) { 
-            if (ClusterVector<int> *clusters = m_source->frontPtr();
-                clusters != nullptr) {
-                // Write clusters to file
-                int32_t frame_number = clusters->frame_number(); //TODO! Should we store frame number already as int?
-                uint32_t num_clusters = clusters->size();
-                m_file.write(reinterpret_cast<const char*>(&frame_number), sizeof(frame_number));
-                m_file.write(reinterpret_cast<const char*>(&num_clusters), sizeof(num_clusters));
-                m_file.write(reinterpret_cast<const char*>(clusters->data()), clusters->size() * clusters->item_size());
-                m_source->popFront();
-            }else{
-                std::this_thread::sleep_for(m_default_wait);
-            }
-        }
-        fmt::print("ClusterFileSink stopped\n");
-        m_stopped = true;
-    }
-
-    public:
-        ClusterFileSink(ClusterFinderMT<uint16_t, double, int32_t>* source, const std::filesystem::path& fname){
-            m_source = source->sink();
-            m_thread = std::thread(&ClusterFileSink::process, this);
-            m_file.open(fname, std::ios::binary);
-        }
-        void stop(){
-            m_stop_requested = true;
-            m_thread.join();
-            m_file.close();
-        }
-};
-
-
-} // namespace aare

include/aare/ClusterFinder.hpp

@@ -1,6 +1,4 @@
 #pragma once
-#include "aare/ClusterFile.hpp"
-#include "aare/ClusterVector.hpp"
 #include "aare/Dtype.hpp"
 #include "aare/NDArray.hpp"
 #include "aare/NDView.hpp"
@@ -10,139 +8,251 @@
 
 namespace aare {
 
-template <typename FRAME_TYPE = uint16_t, typename PEDESTAL_TYPE = double,
-          typename CT = int32_t>
+/** enum to define the event types */
+enum eventType {
+    PEDESTAL,   /** pedestal */
+    NEIGHBOUR,  /** neighbour i.e. below threshold, but in the cluster of a
+                   photon */
+    PHOTON,     /** photon i.e. above threshold */
+    PHOTON_MAX, /** maximum of a cluster satisfying the photon conditions */
+    NEGATIVE_PEDESTAL, /** negative value, will not be accounted for as pedestal
+                          in order to avoid drift of the pedestal towards
+                          negative values */
+    UNDEFINED_EVENT = -1 /** undefined */
+};
+
+template <typename FRAME_TYPE = uint16_t, typename PEDESTAL_TYPE = double>
 class ClusterFinder {
     Shape<2> m_image_size;
     const int m_cluster_sizeX;
     const int m_cluster_sizeY;
-    const PEDESTAL_TYPE m_nSigma;
-    const PEDESTAL_TYPE c2;
-    const PEDESTAL_TYPE c3;
+    const double m_threshold;
+    const double m_nSigma;
+    const double c2;
+    const double c3;
     Pedestal<PEDESTAL_TYPE> m_pedestal;
-    ClusterVector<CT> m_clusters;
 
   public:
-    /**
-     * @brief Construct a new ClusterFinder object
-     * @param image_size size of the image
-     * @param cluster_size size of the cluster (x, y)
-     * @param nSigma number of sigma above the pedestal to consider a photon
-     * @param capacity initial capacity of the cluster vector
-     *
-     */
-    ClusterFinder(Shape<2> image_size, Shape<2> cluster_size,
-                  PEDESTAL_TYPE nSigma = 5.0, size_t capacity = 1000000)
-        : m_image_size(image_size), m_cluster_sizeX(cluster_size[0]),
-          m_cluster_sizeY(cluster_size[1]),
-          m_nSigma(nSigma),
+    ClusterFinder(Shape<2> image_size, Shape<2>cluster_size, double nSigma = 5.0,
+                  double threshold = 0.0)
+        : m_image_size(image_size), m_cluster_sizeX(cluster_size[0]), m_cluster_sizeY(cluster_size[1]),
+          m_threshold(threshold), m_nSigma(nSigma),
           c2(sqrt((m_cluster_sizeY + 1) / 2 * (m_cluster_sizeX + 1) / 2)),
           c3(sqrt(m_cluster_sizeX * m_cluster_sizeY)),
-          m_pedestal(image_size[0], image_size[1]),
-          m_clusters(m_cluster_sizeX, m_cluster_sizeY, capacity) {};
+          m_pedestal(image_size[0], image_size[1]) {
+
+              // c2 = sqrt((cluster_sizeY + 1) / 2 * (cluster_sizeX + 1) / 2);
+              // c3 = sqrt(cluster_sizeX * cluster_sizeY);
+          };
 
     void push_pedestal_frame(NDView<FRAME_TYPE, 2> frame) {
         m_pedestal.push(frame);
     }
 
-    NDArray<PEDESTAL_TYPE, 2> pedestal() { return m_pedestal.mean(); }
-    NDArray<PEDESTAL_TYPE, 2> noise() { return m_pedestal.std(); }
-    void clear_pedestal() { m_pedestal.clear(); }
-
-    /**
-     * @brief Move the clusters from the ClusterVector in the ClusterFinder to a
-     * new ClusterVector and return it.
-     * @param realloc_same_capacity if true the new ClusterVector will have the
-     * same capacity as the old one
-     *
-     */
-    ClusterVector<CT> steal_clusters(bool realloc_same_capacity = false) {
-        ClusterVector<CT> tmp = std::move(m_clusters);
-        if (realloc_same_capacity)
-            m_clusters = ClusterVector<CT>(m_cluster_sizeX, m_cluster_sizeY,
-                                           tmp.capacity());
-        else
-            m_clusters = ClusterVector<CT>(m_cluster_sizeX, m_cluster_sizeY);
-        return tmp;
+    NDArray<PEDESTAL_TYPE, 2> pedestal() {
+        return m_pedestal.mean();
     }
-    void find_clusters(NDView<FRAME_TYPE, 2> frame, uint64_t frame_number = 0) {
-        // // TODO! deal with even size clusters
-        // // currently 3,3 -> +/- 1
-        // //  4,4 -> +/- 2
-        int dy = m_cluster_sizeY / 2;
-        int dx = m_cluster_sizeX / 2;
-        m_clusters.set_frame_number(frame_number);
-        std::vector<CT> cluster_data(m_cluster_sizeX * m_cluster_sizeY);
+
+    std::vector<DynamicCluster>
+    find_clusters_without_threshold(NDView<FRAME_TYPE, 2> frame,
+                                    // Pedestal<PEDESTAL_TYPE> &pedestal,
+                                    bool late_update = false) {
+        struct pedestal_update {
+            int x;
+            int y;
+            FRAME_TYPE value;
+        };
+        std::vector<pedestal_update> pedestal_updates;
+
+        std::vector<DynamicCluster> clusters;
+        std::vector<std::vector<eventType>> eventMask;
+        for (int i = 0; i < frame.shape(0); i++) {
+            eventMask.push_back(std::vector<eventType>(frame.shape(1)));
+        }
+        long double val;
+        long double max;
+
         for (int iy = 0; iy < frame.shape(0); iy++) {
             for (int ix = 0; ix < frame.shape(1); ix++) {
+                // initialize max and total
+                max = std::numeric_limits<FRAME_TYPE>::min();
+                long double total = 0;
+                eventMask[iy][ix] = PEDESTAL;
 
-                PEDESTAL_TYPE max = std::numeric_limits<FRAME_TYPE>::min();
-                PEDESTAL_TYPE total = 0;
-
-                // What can we short circuit here?
-                PEDESTAL_TYPE rms = m_pedestal.std(iy, ix);
-                PEDESTAL_TYPE value = (frame(iy, ix) - m_pedestal.mean(iy, ix));
-
-                if (value < -m_nSigma * rms)
-                    continue; // NEGATIVE_PEDESTAL go to next pixel
-                              // TODO! No pedestal update???
-
-                for (int ir = -dy; ir < dy + 1; ir++) {
-                    for (int ic = -dx; ic < dx + 1; ic++) {
+                for (short ir = -(m_cluster_sizeY / 2);
+                     ir < (m_cluster_sizeY / 2) + 1; ir++) {
+                    for (short ic = -(m_cluster_sizeX / 2);
+                         ic < (m_cluster_sizeX / 2) + 1; ic++) {
                         if (ix + ic >= 0 && ix + ic < frame.shape(1) &&
                             iy + ir >= 0 && iy + ir < frame.shape(0)) {
-                            PEDESTAL_TYPE val =
-                                frame(iy + ir, ix + ic) -
-                                m_pedestal.mean(iy + ir, ix + ic);
-
+                            val = frame(iy + ir, ix + ic) -
+                                  m_pedestal.mean(iy + ir, ix + ic);
                             total += val;
-                            max = std::max(max, val);
+                            if (val > max) {
+                                max = val;
+                            }
                         }
                     }
                 }
+                auto rms = m_pedestal.std(iy, ix);
+
+                if (frame(iy, ix) - m_pedestal.mean(iy, ix) < -m_nSigma * rms) {
+                    eventMask[iy][ix] = NEGATIVE_PEDESTAL;
+                    continue;
+                } else if (max > m_nSigma * rms) {
+                    eventMask[iy][ix] = PHOTON;
 
-                if ((max > m_nSigma * rms)) {
-                    if (value < max)
-                        continue; // Not max go to the next pixel
-                                  // but also no pedestal update
                 } else if (total > c3 * m_nSigma * rms) {
-                    // pass
+                    eventMask[iy][ix] = PHOTON;
                 } else {
-                    // m_pedestal.push(iy, ix, frame(iy, ix));   // Safe option
-                    m_pedestal.push_fast(iy, ix, frame(iy, ix)); // Assume we have reached n_samples in the pedestal, slight performance improvement
-                    continue; // It was a pedestal value nothing to store
+                    if (late_update) {
+                        pedestal_updates.push_back({ix, iy, frame(iy, ix)});
+                    } else {
+                        m_pedestal.push(iy, ix, frame(iy, ix));
+                    }
+                    continue;
                 }
+                if (eventMask[iy][ix] == PHOTON &&
+                    (frame(iy, ix) - m_pedestal.mean(iy, ix)) >= max) {
+                    eventMask[iy][ix] = PHOTON_MAX;
+                    DynamicCluster cluster(m_cluster_sizeX, m_cluster_sizeY,
+                                    Dtype(typeid(PEDESTAL_TYPE)));
+                    cluster.x = ix;
+                    cluster.y = iy;
+                    short i = 0;
 
-                // Store cluster
-                if (value == max) {
-                    // Zero out the cluster data
-                    std::fill(cluster_data.begin(), cluster_data.end(), 0);
-
-                    // Fill the cluster data since we have a photon to store
-                    // It's worth redoing the look since most of the time we
-                    // don't have a photon
-                    int i = 0;
-                    for (int ir = -dy; ir < dy + 1; ir++) {
-                        for (int ic = -dx; ic < dx + 1; ic++) {
+                    for (short ir = -(m_cluster_sizeY / 2);
+                         ir < (m_cluster_sizeY / 2) + 1; ir++) {
+                        for (short ic = -(m_cluster_sizeX / 2);
+                             ic < (m_cluster_sizeX / 2) + 1; ic++) {
                             if (ix + ic >= 0 && ix + ic < frame.shape(1) &&
                                 iy + ir >= 0 && iy + ir < frame.shape(0)) {
-                                CT tmp =
-                                    static_cast<CT>(frame(iy + ir, ix + ic)) -
+                                PEDESTAL_TYPE tmp =
+                                    static_cast<PEDESTAL_TYPE>(
+                                        frame(iy + ir, ix + ic)) -
                                     m_pedestal.mean(iy + ir, ix + ic);
-                                cluster_data[i] =
-                                    tmp; // Watch for out of bounds access
+                                cluster.set<PEDESTAL_TYPE>(i, tmp);
                                 i++;
                             }
                         }
                     }
-
-                    // Add the cluster to the output ClusterVector
-                    m_clusters.push_back(
-                        ix, iy,
-                        reinterpret_cast<std::byte *>(cluster_data.data()));
+                    clusters.push_back(cluster);
                 }
             }
         }
+        if (late_update) {
+            for (auto &update : pedestal_updates) {
+                m_pedestal.push(update.y, update.x, update.value);
+            }
+        }
+        return clusters;
+    }
+
+    // template <typename FRAME_TYPE, typename PEDESTAL_TYPE>
+    std::vector<DynamicCluster>
+    find_clusters_with_threshold(NDView<FRAME_TYPE, 2> frame,
+                                 Pedestal<PEDESTAL_TYPE> &pedestal) {
+        assert(m_threshold > 0);
+        std::vector<DynamicCluster> clusters;
+        std::vector<std::vector<eventType>> eventMask;
+        for (int i = 0; i < frame.shape(0); i++) {
+            eventMask.push_back(std::vector<eventType>(frame.shape(1)));
+        }
+        double tthr, tthr1, tthr2;
+
+        NDArray<FRAME_TYPE, 2> rest({frame.shape(0), frame.shape(1)});
+        NDArray<int, 2> nph({frame.shape(0), frame.shape(1)});
+        // convert to n photons
+        // nph = (frame-pedestal.mean()+0.5*m_threshold)/m_threshold; // can be
+        // optimized with expression templates?
+        for (int iy = 0; iy < frame.shape(0); iy++) {
+            for (int ix = 0; ix < frame.shape(1); ix++) {
+                auto val = frame(iy, ix) - pedestal.mean(iy, ix);
+                nph(iy, ix) = (val + 0.5 * m_threshold) / m_threshold;
+                nph(iy, ix) = nph(iy, ix) < 0 ? 0 : nph(iy, ix);
+                rest(iy, ix) = val - nph(iy, ix) * m_threshold;
+            }
+        }
+        // iterate over frame pixels
+        for (int iy = 0; iy < frame.shape(0); iy++) {
+            for (int ix = 0; ix < frame.shape(1); ix++) {
+                eventMask[iy][ix] = PEDESTAL;
+                // initialize max and total
+                FRAME_TYPE max = std::numeric_limits<FRAME_TYPE>::min();
+                long double total = 0;
+                if (rest(iy, ix) <= 0.25 * m_threshold) {
+                    pedestal.push(iy, ix, frame(iy, ix));
+                    continue;
+                }
+                eventMask[iy][ix] = NEIGHBOUR;
+                // iterate over cluster pixels around the current pixel (ix,iy)
+                for (short ir = -(m_cluster_sizeY / 2);
+                     ir < (m_cluster_sizeY / 2) + 1; ir++) {
+                    for (short ic = -(m_cluster_sizeX / 2);
+                         ic < (m_cluster_sizeX / 2) + 1; ic++) {
+                        if (ix + ic >= 0 && ix + ic < frame.shape(1) &&
+                            iy + ir >= 0 && iy + ir < frame.shape(0)) {
+                            auto val = frame(iy + ir, ix + ic) -
+                                       pedestal.mean(iy + ir, ix + ic);
+                            total += val;
+                            if (val > max) {
+                                max = val;
+                            }
+                        }
+                    }
+                }
+
+                auto rms = pedestal.std(iy, ix);
+                if (m_nSigma == 0) {
+                    tthr = m_threshold;
+                    tthr1 = m_threshold;
+                    tthr2 = m_threshold;
+                } else {
+                    tthr = m_nSigma * rms;
+                    tthr1 = m_nSigma * rms * c3;
+                    tthr2 = m_nSigma * rms * c2;
+
+                    if (m_threshold > 2 * tthr)
+                        tthr = m_threshold - tthr;
+                    if (m_threshold > 2 * tthr1)
+                        tthr1 = tthr - tthr1;
+                    if (m_threshold > 2 * tthr2)
+                        tthr2 = tthr - tthr2;
+                }
+                if (total > tthr1 || max > tthr) {
+                    eventMask[iy][ix] = PHOTON;
+                    nph(iy, ix) += 1;
+                    rest(iy, ix) -= m_threshold;
+                } else {
+                    pedestal.push(iy, ix, frame(iy, ix));
+                    continue;
+                }
+                if (eventMask[iy][ix] == PHOTON &&
+                    frame(iy, ix) - pedestal.mean(iy, ix) >= max) {
+                    eventMask[iy][ix] = PHOTON_MAX;
+                    DynamicCluster cluster(m_cluster_sizeX, m_cluster_sizeY,
+                                    Dtype(typeid(FRAME_TYPE)));
+                    cluster.x = ix;
+                    cluster.y = iy;
+                    short i = 0;
+                    for (short ir = -(m_cluster_sizeY / 2);
+                         ir < (m_cluster_sizeY / 2) + 1; ir++) {
+                        for (short ic = -(m_cluster_sizeX / 2);
+                             ic < (m_cluster_sizeX / 2) + 1; ic++) {
+                            if (ix + ic >= 0 && ix + ic < frame.shape(1) &&
+                                iy + ir >= 0 && iy + ir < frame.shape(0)) {
+                                auto tmp = frame(iy + ir, ix + ic) -
+                                           pedestal.mean(iy + ir, ix + ic);
+                                cluster.set<FRAME_TYPE>(i, tmp);
+                                i++;
+                            }
+                        }
+                    }
+                    clusters.push_back(cluster);
+                }
+            }
+        }
+        return clusters;
     }
 };
 

include/aare/ClusterFinderMT.hpp

@@ -1,268 +0,0 @@
-#pragma once
-#include <atomic>
-#include <cstdint>
-#include <memory>
-#include <thread>
-#include <vector>
-
-#include "aare/ClusterFinder.hpp"
-#include "aare/NDArray.hpp"
-#include "aare/ProducerConsumerQueue.hpp"
-
-namespace aare {
-
-enum class FrameType {
-    DATA,
-    PEDESTAL,
-};
-
-struct FrameWrapper {
-    FrameType type;
-    uint64_t frame_number;
-    NDArray<uint16_t, 2> data;
-};
-
-/**
- * @brief ClusterFinderMT is a multi-threaded version of ClusterFinder. It uses
- * a producer-consumer queue to distribute the frames to the threads. The
- * clusters are collected in a single output queue.
- * @tparam FRAME_TYPE type of the frame data
- * @tparam PEDESTAL_TYPE type of the pedestal data
- * @tparam CT type of the cluster data
- */
-template <typename FRAME_TYPE = uint16_t, typename PEDESTAL_TYPE = double,
-          typename CT = int32_t>
-class ClusterFinderMT {
-    size_t m_current_thread{0};
-    size_t m_n_threads{0};
-    using Finder = ClusterFinder<FRAME_TYPE, PEDESTAL_TYPE, CT>;
-    using InputQueue = ProducerConsumerQueue<FrameWrapper>;
-    using OutputQueue = ProducerConsumerQueue<ClusterVector<int>>;
-    std::vector<std::unique_ptr<InputQueue>> m_input_queues;
-    std::vector<std::unique_ptr<OutputQueue>> m_output_queues;
-
-    OutputQueue m_sink{1000}; // All clusters go into this queue
-
-    std::vector<std::unique_ptr<Finder>> m_cluster_finders;
-    std::vector<std::thread> m_threads;
-    std::thread m_collect_thread;
-    std::chrono::milliseconds m_default_wait{1};
-
-    std::atomic<bool> m_stop_requested{false};
-    std::atomic<bool> m_processing_threads_stopped{true};
-
-    /**
-     * @brief Function called by the processing threads. It reads the frames
-     * from the input queue and processes them.
-     */
-    void process(int thread_id) {
-        auto cf = m_cluster_finders[thread_id].get();
-        auto q = m_input_queues[thread_id].get();
-        bool realloc_same_capacity = true;
-
-        while (!m_stop_requested || !q->isEmpty()) {
-            if (FrameWrapper *frame = q->frontPtr(); frame != nullptr) {
-
-                switch (frame->type) {
-                case FrameType::DATA:
-                    cf->find_clusters(frame->data.view(), frame->frame_number);
-                    m_output_queues[thread_id]->write(cf->steal_clusters(realloc_same_capacity));
-                    break;
-
-                case FrameType::PEDESTAL:
-                    m_cluster_finders[thread_id]->push_pedestal_frame(
-                        frame->data.view());
-                    break;
-                }
-
-                // frame is processed now discard it
-                m_input_queues[thread_id]->popFront();
-            } else {
-                std::this_thread::sleep_for(m_default_wait);
-            }
-        }
-    }
-
-    /**
-     * @brief Collect all the clusters from the output queues and write them to
-     * the sink
-     */
-    void collect() {
-        bool empty = true;
-        while (!m_stop_requested || !empty || !m_processing_threads_stopped) {
-            empty = true;
-            for (auto &queue : m_output_queues) {
-                if (!queue->isEmpty()) {
-
-                    while (!m_sink.write(std::move(*queue->frontPtr()))) {
-                        std::this_thread::sleep_for(m_default_wait);
-                    }
-                    queue->popFront();
-                    empty = false;
-                }
-            }
-        }
-    }
-
-  public:
-    /**
-     * @brief Construct a new ClusterFinderMT object
-     * @param image_size size of the image
-     * @param cluster_size size of the cluster
-     * @param nSigma number of sigma above the pedestal to consider a photon
-     * @param capacity initial capacity of the cluster vector. Should match
-     * expected number of clusters in a frame per frame.
-     * @param n_threads number of threads to use
-     */
-    ClusterFinderMT(Shape<2> image_size, Shape<2> cluster_size,
-                    PEDESTAL_TYPE nSigma = 5.0, size_t capacity = 2000,
-                    size_t n_threads = 3)
-        : m_n_threads(n_threads) {
-        for (size_t i = 0; i < n_threads; i++) {
-            m_cluster_finders.push_back(
-                std::make_unique<ClusterFinder<FRAME_TYPE, PEDESTAL_TYPE, CT>>(
-                    image_size, cluster_size, nSigma, capacity));
-        }
-        for (size_t i = 0; i < n_threads; i++) {
-            m_input_queues.emplace_back(std::make_unique<InputQueue>(200));
-            m_output_queues.emplace_back(std::make_unique<OutputQueue>(200));
-        }
-        //TODO! Should we start automatically?
-        start();
-    }
-
-    /**
-     * @brief Return the sink queue where all the clusters are collected
-     * @warning You need to empty this queue otherwise the cluster finder will wait forever
-     */
-    ProducerConsumerQueue<ClusterVector<int>> *sink() { return &m_sink; }
-
-    /**
-     * @brief Start all processing threads
-     */
-    void start() {
-        m_processing_threads_stopped = false;
-        m_stop_requested = false;
-
-        for (size_t i = 0; i < m_n_threads; i++) {
-            m_threads.push_back(
-                std::thread(&ClusterFinderMT::process, this, i));
-        }
-
-        m_collect_thread = std::thread(&ClusterFinderMT::collect, this);
-    }
-
-    /**
-     * @brief Stop all processing threads
-     */
-    void stop() {
-        m_stop_requested = true;
-
-        for (auto &thread : m_threads) {
-            thread.join();
-        }
-        m_threads.clear();
-
-        m_processing_threads_stopped = true;
-        m_collect_thread.join();
-    }
-
-    /**
-     * @brief Wait for all the queues to be empty. Mostly used for timing tests.
-     */
-    void sync() {
-        for (auto &q : m_input_queues) {
-            while (!q->isEmpty()) {
-                std::this_thread::sleep_for(m_default_wait);
-            }
-        }
-        for (auto &q : m_output_queues) {
-            while (!q->isEmpty()) {
-                std::this_thread::sleep_for(m_default_wait);
-            }
-        }
-        while (!m_sink.isEmpty()) {
-            std::this_thread::sleep_for(m_default_wait);
-        }
-    }
-
-    /**
-     * @brief Push a pedestal frame to all the cluster finders. The frames is
-     * expected to be dark. No photon finding is done. Just pedestal update.
-     */
-    void push_pedestal_frame(NDView<FRAME_TYPE, 2> frame) {
-        FrameWrapper fw{FrameType::PEDESTAL, 0,
-                        NDArray(frame)}; // TODO! copies the data!
-
-        for (auto &queue : m_input_queues) {
-            while (!queue->write(fw)) {
-                std::this_thread::sleep_for(m_default_wait);
-            }
-        }
-    }
-
-    /**
-     * @brief Push the frame to the queue of the next available thread. Function
-     * returns once the frame is in a queue.
-     * @note Spin locks with a default wait if the queue is full.
-     */
-    void find_clusters(NDView<FRAME_TYPE, 2> frame, uint64_t frame_number = 0) {
-        FrameWrapper fw{FrameType::DATA, frame_number,
-                        NDArray(frame)}; // TODO! copies the data!
-        while (!m_input_queues[m_current_thread % m_n_threads]->write(fw)) {
-            std::this_thread::sleep_for(m_default_wait);
-        }
-        m_current_thread++;
-    }
-
-    void clear_pedestal() {
-        if (!m_processing_threads_stopped) {
-            throw std::runtime_error("ClusterFinderMT is still running");
-        }
-        for (auto &cf : m_cluster_finders) {
-            cf->clear_pedestal();
-        }
-    }
-
-    /**
-     * @brief Return the pedestal currently used by the cluster finder
-     * @param thread_index index of the thread
-     */
-    auto pedestal(size_t thread_index = 0) {
-        if (m_cluster_finders.empty()) {
-            throw std::runtime_error("No cluster finders available");
-        }
-        if (!m_processing_threads_stopped) {
-            throw std::runtime_error("ClusterFinderMT is still running");
-        }
-        if (thread_index >= m_cluster_finders.size()) {
-            throw std::runtime_error("Thread index out of range");
-        }
-        return m_cluster_finders[thread_index]->pedestal();
-    }
-
-    /**
-     * @brief Return the noise currently used by the cluster finder
-     * @param thread_index index of the thread
-     */
-    auto noise(size_t thread_index = 0) {
-        if (m_cluster_finders.empty()) {
-            throw std::runtime_error("No cluster finders available");
-        }
-        if (!m_processing_threads_stopped) {
-            throw std::runtime_error("ClusterFinderMT is still running");
-        }
-        if (thread_index >= m_cluster_finders.size()) {
-            throw std::runtime_error("Thread index out of range");
-        }
-        return m_cluster_finders[thread_index]->noise();
-    }
-
-    // void push(FrameWrapper&& frame) {
-    //     //TODO! need to loop until we are successful
-    //     auto rc = m_input_queue.write(std::move(frame));
-    //     fmt::print("pushed frame {}\n", rc);
-    // }
-};
-
-} // namespace aare

include/aare/ClusterVector.hpp

@@ -1,304 +0,0 @@
-#pragma once
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <numeric>
-#include <vector>
-
-#include <fmt/core.h>
-
-#include "aare/Cluster.hpp"
-#include "aare/NDView.hpp"
-
-namespace aare {
-
-/**
- * @brief ClusterVector is a container for clusters of various sizes. It uses a
- * contiguous memory buffer to store the clusters. It is templated on the data
- * type and the coordinate type of the clusters.
- * @note push_back can invalidate pointers to elements in the container
- * @warning ClusterVector is currently move only to catch unintended copies, but
- * this might change since there are probably use cases where copying is needed.
- * @tparam T data type of the pixels in the cluster
- * @tparam CoordType data type of the x and y coordinates of the cluster
- * (normally int16_t)
- */
-template <typename T, typename CoordType = int16_t> class ClusterVector {
-    using value_type = T;
-    size_t m_cluster_size_x;
-    size_t m_cluster_size_y;
-    std::byte *m_data{};
-    size_t m_size{0};
-    size_t m_capacity;
-    uint64_t m_frame_number{0}; // TODO! Check frame number size and type
-    /*
-    Format string used in the python bindings to create a numpy
-    array from the buffer
-    = - native byte order
-    h - short
-    d - double
-    i - int
-    */
-    constexpr static char m_fmt_base[] = "=h:x:\nh:y:\n({},{}){}:data:";
-
-  public:
-    /**
-     * @brief Construct a new ClusterVector object
-     * @param cluster_size_x size of the cluster in x direction
-     * @param cluster_size_y size of the cluster in y direction
-     * @param capacity initial capacity of the buffer in number of clusters
-     * @param frame_number frame number of the clusters. Default is 0, which is
-     * also used to indicate that the clusters come from many frames
-     */
-    ClusterVector(size_t cluster_size_x = 3, size_t cluster_size_y = 3,
-                  size_t capacity = 1024, uint64_t frame_number = 0)
-        : m_cluster_size_x(cluster_size_x), m_cluster_size_y(cluster_size_y),
-          m_capacity(capacity), m_frame_number(frame_number) {
-        allocate_buffer(capacity);
-    }
-
-    ~ClusterVector() { delete[] m_data; }
-
-    // Move constructor
-    ClusterVector(ClusterVector &&other) noexcept
-        : m_cluster_size_x(other.m_cluster_size_x),
-          m_cluster_size_y(other.m_cluster_size_y), m_data(other.m_data),
-          m_size(other.m_size), m_capacity(other.m_capacity),
-          m_frame_number(other.m_frame_number) {
-        other.m_data = nullptr;
-        other.m_size = 0;
-        other.m_capacity = 0;
-    }
-
-    // Move assignment operator
-    ClusterVector &operator=(ClusterVector &&other) noexcept {
-        if (this != &other) {
-            delete[] m_data;
-            m_cluster_size_x = other.m_cluster_size_x;
-            m_cluster_size_y = other.m_cluster_size_y;
-            m_data = other.m_data;
-            m_size = other.m_size;
-            m_capacity = other.m_capacity;
-            m_frame_number = other.m_frame_number;
-            other.m_data = nullptr;
-            other.m_size = 0;
-            other.m_capacity = 0;
-            other.m_frame_number = 0;
-        }
-        return *this;
-    }
-
-    /**
-     * @brief Reserve space for at least capacity clusters
-     * @param capacity number of clusters to reserve space for
-     * @note If capacity is less than the current capacity, the function does
-     * nothing.
-     */
-    void reserve(size_t capacity) {
-        if (capacity > m_capacity) {
-            allocate_buffer(capacity);
-        }
-    }
-
-    /**
-     * @brief Add a cluster to the vector
-     * @param x x-coordinate of the cluster
-     * @param y y-coordinate of the cluster
-     * @param data pointer to the data of the cluster
-     * @warning The data pointer must point to a buffer of size cluster_size_x *
-     * cluster_size_y * sizeof(T)
-     */
-    void push_back(CoordType x, CoordType y, const std::byte *data) {
-        if (m_size == m_capacity) {
-            allocate_buffer(m_capacity * 2);
-        }
-        std::byte *ptr = element_ptr(m_size);
-        *reinterpret_cast<CoordType *>(ptr) = x;
-        ptr += sizeof(CoordType);
-        *reinterpret_cast<CoordType *>(ptr) = y;
-        ptr += sizeof(CoordType);
-
-        std::copy(data, data + m_cluster_size_x * m_cluster_size_y * sizeof(T),
-                  ptr);
-        m_size++;
-    }
-    ClusterVector &operator+=(const ClusterVector &other) {
-        if (m_size + other.m_size > m_capacity) {
-            allocate_buffer(m_capacity + other.m_size);
-        }
-        std::copy(other.m_data, other.m_data + other.m_size * item_size(),
-                  m_data + m_size * item_size());
-        m_size += other.m_size;
-        return *this;
-    }
-
-    /**
-     * @brief Sum the pixels in each cluster
-     * @return std::vector<T> vector of sums for each cluster
-     */
-    std::vector<T> sum() {
-        std::vector<T> sums(m_size);
-        const size_t stride = item_size();
-        const size_t n_pixels = m_cluster_size_x * m_cluster_size_y;
-        std::byte *ptr = m_data + 2 * sizeof(CoordType); // skip x and y
-
-        for (size_t i = 0; i < m_size; i++) {
-            sums[i] =
-                std::accumulate(reinterpret_cast<T *>(ptr),
-                                reinterpret_cast<T *>(ptr) + n_pixels, T{});
-            ptr += stride;
-        }
-        return sums;
-    }
-
-    /**
-     * @brief Return the maximum sum of the 2x2 subclusters in each cluster
-     * @return std::vector<T> vector of sums for each cluster
-     * @throws std::runtime_error if the cluster size is not 3x3
-     * @warning Only 3x3 clusters are supported for the 2x2 sum.
-     */
-    std::vector<T> sum_2x2() {
-        std::vector<T> sums(m_size);
-        const size_t stride = item_size();
-
-        if (m_cluster_size_x != 3 || m_cluster_size_y != 3) {
-            throw std::runtime_error(
-                "Only 3x3 clusters are supported for the 2x2 sum.");
-        }
-        std::byte *ptr = m_data + 2 * sizeof(CoordType); // skip x and y
-
-        for (size_t i = 0; i < m_size; i++) {
-            std::array<T, 4> total;
-            auto T_ptr = reinterpret_cast<T *>(ptr);
-            total[0] = T_ptr[0] + T_ptr[1] + T_ptr[3] + T_ptr[4];
-            total[1] = T_ptr[1] + T_ptr[2] + T_ptr[4] + T_ptr[5];
-            total[2] = T_ptr[3] + T_ptr[4] + T_ptr[6] + T_ptr[7];
-            total[3] = T_ptr[4] + T_ptr[5] + T_ptr[7] + T_ptr[8];
-
-            sums[i] = *std::max_element(total.begin(), total.end());
-            ptr += stride;
-        }
-
-        return sums;
-    }
-
-    /**
-     * @brief Return the number of clusters in the vector
-     */
-    size_t size() const { return m_size; }
-
-    /**
-     * @brief Return the capacity of the buffer in number of clusters. This is
-     * the number of clusters that can be stored in the current buffer without
-     * reallocation.
-     */
-    size_t capacity() const { return m_capacity; }
-
-    /**
-     * @brief Return the size in bytes of a single cluster
-     */
-    size_t item_size() const {
-        return 2 * sizeof(CoordType) +
-               m_cluster_size_x * m_cluster_size_y * sizeof(T);
-    }
-
-    /**
-     * @brief Return the offset in bytes for the i-th cluster
-     */
-    size_t element_offset(size_t i) const { return item_size() * i; }
-
-    /**
-     * @brief Return a pointer to the i-th cluster
-     */
-    std::byte *element_ptr(size_t i) { return m_data + element_offset(i); }
-
-    /**
-     * @brief Return a pointer to the i-th cluster
-     */
-    const std::byte *element_ptr(size_t i) const {
-        return m_data + element_offset(i);
-    }
-
-    size_t cluster_size_x() const { return m_cluster_size_x; }
-    size_t cluster_size_y() const { return m_cluster_size_y; }
-
-    std::byte *data() { return m_data; }
-    std::byte const *data() const { return m_data; }
-
-    /**
-     * @brief Return a reference to the i-th cluster casted to type V
-     * @tparam V type of the cluster
-     */
-    template <typename V> V &at(size_t i) {
-        return *reinterpret_cast<V *>(element_ptr(i));
-    }
-
-    template <typename V> const V &at(size_t i) const {
-        return *reinterpret_cast<const V *>(element_ptr(i));
-    }
-
-    const std::string_view fmt_base() const {
-        // TODO! how do we match on coord_t?
-        return m_fmt_base;
-    }
-
-    /**
-     * @brief Return the frame number of the clusters. 0 is used to indicate
-     * that the clusters come from many frames
-     */
-    uint64_t frame_number() const { return m_frame_number; }
-
-    void set_frame_number(uint64_t frame_number) {
-        m_frame_number = frame_number;
-    }
-
-    /**
-     * @brief Resize the vector to contain new_size clusters. If new_size is
-     * greater than the current capacity, a new buffer is allocated. If the size
-     * is smaller no memory is freed, size is just updated.
-     * @param new_size new size of the vector
-     * @warning The additional clusters are not initialized
-     */
-    void resize(size_t new_size) {
-        // TODO! Should we initialize the new clusters?
-        if (new_size > m_capacity) {
-            allocate_buffer(new_size);
-        }
-        m_size = new_size;
-    }
-
-    void apply_gain_map(const NDView<double> gain_map){
-        //in principle we need to know the size of the image for this lookup
-        //TODO! check orientations
-        std::array<int64_t, 9> xcorr = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
-        std::array<int64_t, 9> ycorr = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
-        for (size_t i=0; i<m_size; i++){
-            auto& cl = at<Cluster3x3>(i);
-
-            if (cl.x > 0 && cl.y > 0 && cl.x < gain_map.shape(1)-1 && cl.y < gain_map.shape(0)-1){
-                for (size_t j=0; j<9; j++){
-                    size_t x = cl.x + xcorr[j];
-                    size_t y = cl.y + ycorr[j];
-                    cl.data[j] = static_cast<T>(cl.data[j] * gain_map(y, x));
-                }
-            }else{
-                memset(cl.data, 0, 9*sizeof(T)); //clear edge clusters
-            }
-
-            
-        }
-    }
-
-  private:
-    void allocate_buffer(size_t new_capacity) {
-        size_t num_bytes = item_size() * new_capacity;
-        std::byte *new_data = new std::byte[num_bytes]{};
-        std::copy(m_data, m_data + item_size() * m_size, new_data);
-        delete[] m_data;
-        m_data = new_data;
-        m_capacity = new_capacity;
-    }
-};
-
-} // namespace aare

include/aare/File.hpp

@@ -36,8 +36,6 @@ class File {
     File(File &&other) noexcept;
     File& operator=(File &&other) noexcept;
     ~File() = default;
-
-    // void close();                             //!< close the file
       
     Frame read_frame();                       //!< read one frame from the file at the current position
     Frame read_frame(size_t frame_index);     //!< read one frame at the position given by frame number
@@ -46,7 +44,6 @@ class File {
     void read_into(std::byte *image_buf);
     void read_into(std::byte *image_buf, size_t n_frames);
     
-    size_t frame_number();                    //!< get the frame number at the current position
     size_t frame_number(size_t frame_index);  //!< get the frame number at the given frame index
     size_t bytes_per_frame() const;           
     size_t pixels_per_frame() const;    

include/aare/FilePtr.hpp

@@ -1,30 +0,0 @@
-#pragma once
-#include <cstdio>
-#include <filesystem>
-
-namespace aare {
-
-/**
- * \brief RAII wrapper for FILE pointer
- */
-class FilePtr {
-    FILE *fp_{nullptr};
-
-  public:
-    FilePtr() = default;
-    FilePtr(const std::filesystem::path& fname, const std::string& mode);
-    FilePtr(const FilePtr &) = delete;            // we don't want a copy
-    FilePtr &operator=(const FilePtr &) = delete; // since we handle a resource
-    FilePtr(FilePtr &&other);
-    FilePtr &operator=(FilePtr &&other);
-    FILE *get();
-    int64_t tell();
-    void seek(int64_t offset, int whence = SEEK_SET) {
-        if (fseek(fp_, offset, whence) != 0)
-            throw std::runtime_error("Error seeking in file");
-    }
-    std::string error_msg();
-    ~FilePtr();
-};
-
-} // namespace aare

include/aare/Fit.hpp

@@ -1,92 +0,0 @@
-#pragma once
-
-#include <cmath>
-#include <fmt/core.h>
-#include <vector>
-
-#include "aare/NDArray.hpp"
-
-namespace aare {
-
-namespace func {
-double gaus(const double x, const double *par);
-NDArray<double, 1> gaus(NDView<double, 1> x, NDView<double, 1> par);
-
-double pol1(const double x, const double *par);
-NDArray<double, 1> pol1(NDView<double, 1> x, NDView<double, 1> par);
-
-} // namespace func
-
-
-/**
- * @brief Estimate the initial parameters for a Gaussian fit
- */
-std::array<double, 3> gaus_init_par(const NDView<double, 1> x, const NDView<double, 1> y);
-
-std::array<double, 2> pol1_init_par(const NDView<double, 1> x, const NDView<double, 1> y);
-
-static constexpr int DEFAULT_NUM_THREADS = 4;
-
-/**
- * @brief Fit a 1D Gaussian to data.
- * @param data data to fit
- * @param x x values
- */
-NDArray<double, 1> fit_gaus(NDView<double, 1> x, NDView<double, 1> y);
-
-
-/**
- * @brief Fit a 1D Gaussian to each pixel. Data layout [row, col, values]
- * @param x x values
- * @param y y vales, layout [row, col, values]
- * @param n_threads number of threads to use
- */
-
-NDArray<double, 3> fit_gaus(NDView<double, 1> x, NDView<double, 3> y,
-                            int n_threads = DEFAULT_NUM_THREADS);
-
-
-
-
-/**
- * @brief Fit a 1D Gaussian with error estimates
- * @param x x values
- * @param y y vales, layout [row, col, values]
- * @param y_err error in y, layout [row, col, values]
- * @param par_out output parameters
- * @param par_err_out output error parameters
- */
-void fit_gaus(NDView<double, 1> x, NDView<double, 1> y, NDView<double, 1> y_err,
-              NDView<double, 1> par_out, NDView<double, 1> par_err_out,
-              double& chi2);
-
-/**
- * @brief Fit a 1D Gaussian to each pixel with error estimates. Data layout
- * [row, col, values]
- * @param x x values
- * @param y y vales, layout [row, col, values]
- * @param y_err error in y, layout [row, col, values]
- * @param par_out output parameters, layout [row, col, values]
- * @param par_err_out output parameter errors, layout [row, col, values]
- * @param n_threads number of threads to use
- */
-void fit_gaus(NDView<double, 1> x, NDView<double, 3> y, NDView<double, 3> y_err,
-              NDView<double, 3> par_out, NDView<double, 3> par_err_out, NDView<double, 2> chi2_out,
-              int n_threads = DEFAULT_NUM_THREADS
-              );
-
-NDArray<double, 1> fit_pol1(NDView<double, 1> x, NDView<double, 1> y);
-
-NDArray<double, 3> fit_pol1(NDView<double, 1> x, NDView<double, 3> y,
-                            int n_threads = DEFAULT_NUM_THREADS);
-
-void fit_pol1(NDView<double, 1> x, NDView<double, 1> y, NDView<double, 1> y_err,
-              NDView<double, 1> par_out, NDView<double, 1> par_err_out, double& chi2);
-
-// TODO! not sure we need to offer the different version in C++
-void fit_pol1(NDView<double, 1> x, NDView<double, 3> y, NDView<double, 3> y_err,
-              NDView<double, 3> par_out, NDView<double, 3> par_err_out,NDView<double, 2> chi2_out,
-              int n_threads = DEFAULT_NUM_THREADS);
-
-
-} // namespace aare

include/aare/Interpolator.hpp

@@ -1,29 +0,0 @@
-#pragma once
-#include "aare/NDArray.hpp"
-#include "aare/NDView.hpp"
-#include "aare/ClusterVector.hpp"
-#include "aare/ClusterFile.hpp" //Cluster_3x3
-namespace aare{
-
-struct Photon{
-    double x;
-    double y;
-    double energy;
-};
-
-class Interpolator{
-    NDArray<double, 3> m_ietax;
-    NDArray<double, 3> m_ietay;
-
-    NDArray<double, 1> m_etabinsx;
-    NDArray<double, 1> m_etabinsy;
-    NDArray<double, 1> m_energy_bins;
-    public:
-        Interpolator(NDView<double, 3> etacube, NDView<double, 1> xbins, NDView<double, 1> ybins, NDView<double, 1> ebins);
-        NDArray<double, 3> get_ietax(){return m_ietax;}
-        NDArray<double, 3> get_ietay(){return m_ietay;}
-
-        std::vector<Photon> interpolate(const ClusterVector<int32_t>& clusters);
-};
-
-} // namespace aare

include/aare/JungfrauDataFile.hpp

@@ -1,106 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <filesystem>
-#include <vector>
-
-#include "aare/FilePtr.hpp"
-#include "aare/defs.hpp"
-#include "aare/NDArray.hpp"
-#include "aare/FileInterface.hpp"
-namespace aare {
-
-
-struct JungfrauDataHeader{
-    uint64_t framenum;
-    uint64_t bunchid;
-};
-
-class JungfrauDataFile : public FileInterface {
-
-    size_t m_rows{};     //!< number of rows in the image, from find_frame_size();
-    size_t m_cols{};     //!< number of columns in the image, from find_frame_size();
-    size_t m_bytes_per_frame{}; //!< number of bytes per frame excluding header
-    size_t m_total_frames{};    //!< total number of frames in the series of files
-    size_t m_offset{}; //!< file index of the first file, allow starting at non zero file
-    size_t m_current_file_index{};   //!< The index of the open file
-    size_t m_current_frame_index{};  //!< The index of the current frame (with reference to all files)
-
-    std::vector<size_t> m_last_frame_in_file{}; //!< Used for seeking to the correct file
-    std::filesystem::path m_path; //!< path to the files
-    std::string m_base_name;      //!< base name used for formatting file names
-
-    FilePtr m_fp; //!< RAII wrapper for a FILE* 
-
-    
-    using pixel_type = uint16_t;
-    static constexpr size_t header_size = sizeof(JungfrauDataHeader); 
-    static constexpr size_t n_digits_in_file_index = 6; //!< to format file names
-
-  public:
-    JungfrauDataFile(const std::filesystem::path &fname);
-
-    std::string base_name() const;      //!< get the base name of the file (without path and extension)
-    size_t bytes_per_frame() override;           
-    size_t pixels_per_frame() override;    
-    size_t bytes_per_pixel() const;  
-    size_t bitdepth() const override;
-    void seek(size_t frame_index) override;  //!< seek to the given frame index (note not byte offset)
-    size_t tell() override;            //!< get the frame index of the file pointer
-    size_t total_frames() const override;
-    size_t rows() const override;
-    size_t cols() const override;
-    std::array<ssize_t,2> shape() const;
-    size_t n_files() const; //!< get the number of files in the series. 
-
-    // Extra functions needed for FileInterface
-    Frame read_frame() override;
-    Frame read_frame(size_t frame_number) override;
-    std::vector<Frame> read_n(size_t n_frames=0) override;
-    void read_into(std::byte *image_buf) override;
-    void read_into(std::byte *image_buf, size_t n_frames) override;
-    size_t frame_number(size_t frame_index) override;
-    DetectorType detector_type() const override;
-
-    /**
-     * @brief Read a single frame from the file into the given buffer.  
-     * @param image_buf buffer to read the frame into. (Note the caller is responsible for allocating the buffer)
-     * @param header pointer to a JungfrauDataHeader or nullptr to skip header)
-     */
-    void read_into(std::byte *image_buf, JungfrauDataHeader *header = nullptr);
-
-    /**
-     * @brief Read a multiple frames from the file into the given buffer.  
-     * @param image_buf buffer to read the frame into. (Note the caller is responsible for allocating the buffer)
-     * @param n_frames number of frames to read
-     * @param header pointer to a JungfrauDataHeader or nullptr to skip header)
-     */
-    void read_into(std::byte *image_buf, size_t n_frames, JungfrauDataHeader *header = nullptr);
-    
-    /** 
-     * @brief Read a single frame from the file into the given NDArray
-     * @param image NDArray to read the frame into.
-     */
-    void read_into(NDArray<uint16_t>* image, JungfrauDataHeader* header = nullptr);
-
-    JungfrauDataHeader read_header();
-    std::filesystem::path current_file() const { return fpath(m_current_file_index+m_offset); }
-
-    
-    private:
-    /**
-     * @brief Find the size of the frame in the file. (256x256, 256x1024, 512x1024)
-     * @param fname path to the file
-     * @throws std::runtime_error if the file is empty or the size cannot be determined
-     */
-     void find_frame_size(const std::filesystem::path &fname);
-
-
-     void parse_fname(const std::filesystem::path &fname);
-     void scan_files();
-     void open_file(size_t file_index);
-     std::filesystem::path fpath(size_t frame_index) const;
-
-
-  };
-
-} // namespace aare

include/aare/NDArray.hpp

@@ -69,11 +69,6 @@ class NDArray : public ArrayExpr<NDArray<T, Ndim>, Ndim> {
         std::copy(v.begin(), v.end(), begin());
     }
 
-    template<size_t Size>
-    NDArray(const std::array<T, Size>& arr) : NDArray<T,1>({Size}) {
-        std::copy(arr.begin(), arr.end(), begin());
-    }
-
     // Move constructor
     NDArray(NDArray &&other) noexcept
         : shape_(other.shape_), strides_(c_strides<Ndim>(shape_)),
@@ -92,7 +87,7 @@ class NDArray : public ArrayExpr<NDArray<T, Ndim>, Ndim> {
     // Conversion operator from array expression to array
     template <typename E>
     NDArray(ArrayExpr<E, Ndim> &&expr) : NDArray(expr.shape()) {
-        for (size_t i = 0; i < size_; ++i) {
+        for (int i = 0; i < size_; ++i) {
             data_[i] = expr[i];
         }
     }
@@ -102,9 +97,6 @@ class NDArray : public ArrayExpr<NDArray<T, Ndim>, Ndim> {
     auto begin() { return data_; }
     auto end() { return data_ + size_; }
 
-    auto begin() const { return data_; }
-    auto end() const { return data_ + size_; }
-
     using value_type = T;
 
     NDArray &operator=(NDArray &&other) noexcept; // Move assign
@@ -113,20 +105,6 @@ class NDArray : public ArrayExpr<NDArray<T, Ndim>, Ndim> {
     NDArray &operator-=(const NDArray &other);
     NDArray &operator*=(const NDArray &other);
 
-    //Write directly to the data array, or create a new one
-    template<size_t Size>
-    NDArray<T,1>& operator=(const std::array<T,Size> &other){
-        if(Size != size_){
-            delete[] data_;
-            size_ = Size;
-            data_ = new T[size_];
-        }
-        for (size_t i = 0; i < Size; ++i) {
-            data_[i] = other[i];
-        }
-        return *this;
-    }
-
     // NDArray& operator/=(const NDArray& other);
 
     template <typename V> NDArray &operator/=(const NDArray<V, Ndim> &other) {
@@ -157,11 +135,6 @@ class NDArray : public ArrayExpr<NDArray<T, Ndim>, Ndim> {
 
     NDArray &operator&=(const T & /*mask*/);
 
-  
-
-
-    
-
     void sqrt() {
         for (int i = 0; i < size_; ++i) {
             data_[i] = std::sqrt(data_[i]);
@@ -186,15 +159,15 @@ class NDArray : public ArrayExpr<NDArray<T, Ndim>, Ndim> {
     }
 
     // TODO! is int the right type for index?
-    T &operator()(int64_t i) { return data_[i]; }
-    const T &operator()(int64_t i) const { return data_[i]; }
+    T &operator()(int i) { return data_[i]; }
+    const T &operator()(int i) const { return data_[i]; }
 
-    T &operator[](int64_t i) { return data_[i]; }
-    const T &operator[](int64_t i) const { return data_[i]; }
+    T &operator[](int i) { return data_[i]; }
+    const T &operator[](int i) const { return data_[i]; }
 
     T *data() { return data_; }
     std::byte *buffer() { return reinterpret_cast<std::byte *>(data_); }
-    ssize_t size() const { return static_cast<ssize_t>(size_); }
+    size_t size() const { return size_; }
     size_t total_bytes() const { return size_ * sizeof(T); }
     std::array<int64_t, Ndim> shape() const noexcept { return shape_; }
     int64_t shape(int64_t i) const noexcept { return shape_[i]; }
@@ -345,9 +318,6 @@ NDArray<T, Ndim> &NDArray<T, Ndim>::operator+=(const T &value) {
     return *this;
 }
 
-
-
-
 template <typename T, int64_t Ndim>
 NDArray<T, Ndim> NDArray<T, Ndim>::operator+(const T &value) {
     NDArray result = *this;
@@ -391,12 +361,12 @@ NDArray<T, Ndim> NDArray<T, Ndim>::operator*(const T &value) {
     result *= value;
     return result;
 }
-// template <typename T, int64_t Ndim> void NDArray<T, Ndim>::Print() {
-//     if (shape_[0] < 20 && shape_[1] < 20)
-//         Print_all();
-//     else
-//         Print_some();
-// }
+template <typename T, int64_t Ndim> void NDArray<T, Ndim>::Print() {
+    if (shape_[0] < 20 && shape_[1] < 20)
+        Print_all();
+    else
+        Print_some();
+}
 
 template <typename T, int64_t Ndim>
 std::ostream &operator<<(std::ostream &os, const NDArray<T, Ndim> &arr) {
@@ -448,6 +418,4 @@ NDArray<T, Ndim> load(const std::string &pathname,
     return img;
 }
 
-
-
 } // namespace aare

include/aare/NDView.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include "aare/defs.hpp"
+
 #include "aare/ArrayExpr.hpp"
 
 #include <algorithm>
@@ -71,7 +71,7 @@ template <typename T, int64_t Ndim = 2> class NDView : public ArrayExpr<NDView<T
         return buffer_[element_offset(strides_, index...)];
     }
 
-    ssize_t size() const { return static_cast<ssize_t>(size_); }
+    size_t size() const { return size_; }
     size_t total_bytes() const { return size_ * sizeof(T); }
     std::array<int64_t, Ndim> strides() const noexcept { return strides_; }
 
@@ -99,15 +99,6 @@ template <typename T, int64_t Ndim = 2> class NDView : public ArrayExpr<NDView<T
 
     NDView &operator/=(const NDView &other) { return elemenwise(other, std::divides<T>()); }
 
-
-    template<size_t Size>
-    NDView& operator=(const std::array<T, Size> &arr) {
-        if(size() != static_cast<ssize_t>(arr.size()))
-            throw std::runtime_error(LOCATION + "Array and NDView size mismatch");
-        std::copy(arr.begin(), arr.end(), begin());
-        return *this;
-    }
-
     NDView &operator=(const T val) {
         for (auto it = begin(); it != end(); ++it)
             *it = val;
@@ -184,9 +175,4 @@ std::ostream& operator <<(std::ostream& os, const NDView<T, Ndim>& arr){
 }
 
 
-template <typename T>
-NDView<T,1> make_view(std::vector<T>& vec){
-    return NDView<T,1>(vec.data(), {static_cast<int64_t>(vec.size())});
-}
-
 } // namespace aare

include/aare/Pedestal.hpp

@@ -18,48 +18,34 @@ template <typename SUM_TYPE = double> class Pedestal {
 
     uint32_t m_samples;
     NDArray<uint32_t, 2> m_cur_samples;
-    
-    //TODO! in case of int needs to be changed to uint64_t
     NDArray<SUM_TYPE, 2> m_sum;
     NDArray<SUM_TYPE, 2> m_sum2;
 
-    //Cache mean since it is used over and over in the ClusterFinder
-    //This optimization is related to the access pattern of the ClusterFinder
-    //Relies on having more reads than pushes to the pedestal
-    NDArray<SUM_TYPE, 2> m_mean; 
-
   public:
     Pedestal(uint32_t rows, uint32_t cols, uint32_t n_samples = 1000)
         : m_rows(rows), m_cols(cols), m_samples(n_samples),
           m_cur_samples(NDArray<uint32_t, 2>({rows, cols}, 0)),
           m_sum(NDArray<SUM_TYPE, 2>({rows, cols})),
-          m_sum2(NDArray<SUM_TYPE, 2>({rows, cols})),
-          m_mean(NDArray<SUM_TYPE, 2>({rows, cols})) {
+          m_sum2(NDArray<SUM_TYPE, 2>({rows, cols})) {
         assert(rows > 0 && cols > 0 && n_samples > 0);
         m_sum = 0;
         m_sum2 = 0;
-        m_mean = 0;
     }
     ~Pedestal() = default;
 
     NDArray<SUM_TYPE, 2> mean() {
-        return m_mean;
+        NDArray<SUM_TYPE, 2> mean_array({m_rows, m_cols});
+        for (uint32_t i = 0; i < m_rows * m_cols; i++) {
+            mean_array(i / m_cols, i % m_cols) = mean(i / m_cols, i % m_cols);
+        }
+        return mean_array;
     }
 
     SUM_TYPE mean(const uint32_t row, const uint32_t col) const {
-        return m_mean(row, col);
-    }
-
-    SUM_TYPE std(const uint32_t row, const uint32_t col) const {
-        return std::sqrt(variance(row, col));
-    }
-
-    SUM_TYPE variance(const uint32_t row, const uint32_t col) const {
         if (m_cur_samples(row, col) == 0) {
             return 0.0;
         }
-        return m_sum2(row, col) / m_cur_samples(row, col) -
-               mean(row, col) * mean(row, col);
+        return m_sum(row, col) / m_cur_samples(row, col);
     }
 
     NDArray<SUM_TYPE, 2> variance() {
@@ -71,7 +57,13 @@ template <typename SUM_TYPE = double> class Pedestal {
         return variance_array;
     }
 
-    
+    SUM_TYPE variance(const uint32_t row, const uint32_t col) const {
+        if (m_cur_samples(row, col) == 0) {
+            return 0.0;
+        }
+        return m_sum2(row, col) / m_cur_samples(row, col) -
+               mean(row, col) * mean(row, col);
+    }
 
     NDArray<SUM_TYPE, 2> std() {
         NDArray<SUM_TYPE, 2> standard_deviation_array({m_rows, m_cols});
@@ -83,13 +75,14 @@ template <typename SUM_TYPE = double> class Pedestal {
         return standard_deviation_array;
     }
 
-    
+    SUM_TYPE std(const uint32_t row, const uint32_t col) const {
+        return std::sqrt(variance(row, col));
+    }
 
     void clear() {
-        m_sum = 0;
-        m_sum2 = 0;
-        m_cur_samples = 0;
-        m_mean = 0;
+        for (uint32_t i = 0; i < m_rows * m_cols; i++) {
+            clear(i / m_cols, i % m_cols);
+        }
     }
 
     
@@ -98,11 +91,8 @@ template <typename SUM_TYPE = double> class Pedestal {
         m_sum(row, col) = 0;
         m_sum2(row, col) = 0;
         m_cur_samples(row, col) = 0;
-        m_mean(row, col) = 0;
     }
-    
-
-
+    // frame level operations
     template <typename T> void push(NDView<T, 2> frame) {
         assert(frame.size() == m_rows * m_cols);
 
@@ -112,37 +102,17 @@ template <typename SUM_TYPE = double> class Pedestal {
                 "Frame shape does not match pedestal shape");
         }
 
-        for (size_t row = 0; row < m_rows; row++) {
-            for (size_t col = 0; col < m_cols; col++) {
+        for (uint32_t row = 0; row < m_rows; row++) {
+            for (uint32_t col = 0; col < m_cols; col++) {
                 push<T>(row, col, frame(row, col));
             }
         }
+
+        // // TODO: test the effect of #pragma omp parallel for
+        // for (uint32_t index = 0; index < m_rows * m_cols; index++) {
+        //     push<T>(index / m_cols, index % m_cols, frame(index));
+        // }
     }
-
-    /**
-     * Push but don't update the cached mean. Speeds up the process
-     * when initializing the pedestal.
-     * 
-     */
-    template <typename T> void push_no_update(NDView<T, 2> frame) {
-        assert(frame.size() == m_rows * m_cols);
-
-        // TODO! move away from m_rows, m_cols
-        if (frame.shape() != std::array<int64_t, 2>{m_rows, m_cols}) {
-            throw std::runtime_error(
-                "Frame shape does not match pedestal shape");
-        }
-
-        for (size_t row = 0; row < m_rows; row++) {
-            for (size_t col = 0; col < m_cols; col++) {
-                push_no_update<T>(row, col, frame(row, col));
-            }
-        }
-    }
-
-
-
-
     template <typename T> void push(Frame &frame) {
         assert(frame.rows() == static_cast<size_t>(m_rows) &&
                frame.cols() == static_cast<size_t>(m_cols));
@@ -162,48 +132,18 @@ template <typename SUM_TYPE = double> class Pedestal {
     template <typename T>
     void push(const uint32_t row, const uint32_t col, const T val_) {
         SUM_TYPE val = static_cast<SUM_TYPE>(val_);
-        if (m_cur_samples(row, col) < m_samples) {
-            m_sum(row, col) += val;
-            m_sum2(row, col) += val * val;
-            m_cur_samples(row, col)++;
+        const uint32_t idx = index(row, col);
+        if (m_cur_samples(idx) < m_samples) {
+            m_sum(idx) += val;
+            m_sum2(idx) += val * val;
+            m_cur_samples(idx)++;
         } else {
-            m_sum(row, col) += val - m_sum(row, col) / m_samples;
-            m_sum2(row, col) += val * val - m_sum2(row, col) / m_samples;
-        }
-        //Since we just did a push we know that m_cur_samples(row, col) is at least 1
-        m_mean(row, col) = m_sum(row, col) / m_cur_samples(row, col);
-    }
-
-    template <typename T>
-    void push_no_update(const uint32_t row, const uint32_t col, const T val_) {
-        SUM_TYPE val = static_cast<SUM_TYPE>(val_);
-        if (m_cur_samples(row, col) < m_samples) {
-            m_sum(row, col) += val;
-            m_sum2(row, col) += val * val;
-            m_cur_samples(row, col)++;
-        } else {
-            m_sum(row, col) += val - m_sum(row, col) / m_cur_samples(row, col);
-            m_sum2(row, col) += val * val - m_sum2(row, col) / m_cur_samples(row, col);
+            m_sum(idx) += val - m_sum(idx) / m_cur_samples(idx);
+            m_sum2(idx) += val * val - m_sum2(idx) / m_cur_samples(idx);
         }
     }
-
-    /**
-     * @brief Update the mean of the pedestal. This is used after having done
-     * push_no_update. It is not necessary to call this function after push.
-     */
-    void update_mean(){
-        m_mean = m_sum / m_cur_samples;
-    }
-
-    template<typename T>
-    void push_fast(const uint32_t row, const uint32_t col, const T val_){
-        //Assume we reached the steady state where all pixels have
-        //m_samples samples
-        SUM_TYPE val = static_cast<SUM_TYPE>(val_);
-        m_sum(row, col) += val - m_sum(row, col) / m_samples;
-        m_sum2(row, col) += val * val - m_sum2(row, col) / m_samples;
-        m_mean(row, col) = m_sum(row, col) / m_samples;
-    }
-
+    uint32_t index(const uint32_t row, const uint32_t col) const {
+        return row * m_cols + col;
+    };
 };
 } // namespace aare

include/aare/ProducerConsumerQueue.hpp

@@ -1,203 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// @author Bo Hu (bhu@fb.com)
-// @author Jordan DeLong (delong.j@fb.com)
-
-// Changes made by PSD Detector Group:
-// Copied: Line 34 constexpr std::size_t hardware_destructive_interference_size = 128; from folly/lang/Align.h
-// Changed extension to .hpp
-// Changed namespace to aare
-
-#pragma once
-
-#include <atomic>
-#include <cassert>
-#include <cstdlib>
-#include <memory>
-#include <stdexcept>
-#include <type_traits>
-#include <utility>
-
-constexpr std::size_t hardware_destructive_interference_size = 128;
-namespace aare {
-
-/*
- * ProducerConsumerQueue is a one producer and one consumer queue
- * without locks.
- */
-template <class T> struct ProducerConsumerQueue {
-    typedef T value_type;
-
-    ProducerConsumerQueue(const ProducerConsumerQueue &) = delete;
-    ProducerConsumerQueue &operator=(const ProducerConsumerQueue &) = delete;
-
-    
-    ProducerConsumerQueue(ProducerConsumerQueue &&other){
-        size_ = other.size_;
-        records_ = other.records_;
-        other.records_ = nullptr;
-        readIndex_ = other.readIndex_.load(std::memory_order_acquire);
-        writeIndex_ = other.writeIndex_.load(std::memory_order_acquire);
-    }
-    ProducerConsumerQueue &operator=(ProducerConsumerQueue &&other){
-        size_ = other.size_;
-        records_ = other.records_;
-        other.records_ = nullptr;
-        readIndex_ = other.readIndex_.load(std::memory_order_acquire);
-        writeIndex_ = other.writeIndex_.load(std::memory_order_acquire);
-        return *this;
-    }
-    
-    
-    ProducerConsumerQueue():ProducerConsumerQueue(2){};
-    // size must be >= 2.
-    //
-    // Also, note that the number of usable slots in the queue at any
-    // given time is actually (size-1), so if you start with an empty queue,
-    // isFull() will return true after size-1 insertions.
-    explicit ProducerConsumerQueue(uint32_t size)
-        : size_(size), records_(static_cast<T *>(std::malloc(sizeof(T) * size))), readIndex_(0), writeIndex_(0) {
-        assert(size >= 2);
-        if (!records_) {
-            throw std::bad_alloc();
-        }
-    }
-
-    ~ProducerConsumerQueue() {
-        // We need to destruct anything that may still exist in our queue.
-        // (No real synchronization needed at destructor time: only one
-        // thread can be doing this.)
-        if (!std::is_trivially_destructible<T>::value) {
-            size_t readIndex = readIndex_;
-            size_t endIndex = writeIndex_;
-            while (readIndex != endIndex) {
-                records_[readIndex].~T();
-                if (++readIndex == size_) {
-                    readIndex = 0;
-                }
-            }
-        }
-
-        std::free(records_);
-    }
-
-    template <class... Args> bool write(Args &&...recordArgs) {
-        auto const currentWrite = writeIndex_.load(std::memory_order_relaxed);
-        auto nextRecord = currentWrite + 1;
-        if (nextRecord == size_) {
-            nextRecord = 0;
-        }
-        if (nextRecord != readIndex_.load(std::memory_order_acquire)) {
-            new (&records_[currentWrite]) T(std::forward<Args>(recordArgs)...);
-            writeIndex_.store(nextRecord, std::memory_order_release);
-            return true;
-        }
-
-        // queue is full
-        return false;
-    }
-
-    // move (or copy) the value at the front of the queue to given variable
-    bool read(T &record) {
-        auto const currentRead = readIndex_.load(std::memory_order_relaxed);
-        if (currentRead == writeIndex_.load(std::memory_order_acquire)) {
-            // queue is empty
-            return false;
-        }
-
-        auto nextRecord = currentRead + 1;
-        if (nextRecord == size_) {
-            nextRecord = 0;
-        }
-        record = std::move(records_[currentRead]);
-        records_[currentRead].~T();
-        readIndex_.store(nextRecord, std::memory_order_release);
-        return true;
-    }
-
-    // pointer to the value at the front of the queue (for use in-place) or
-    // nullptr if empty.
-    T *frontPtr() {
-        auto const currentRead = readIndex_.load(std::memory_order_relaxed);
-        if (currentRead == writeIndex_.load(std::memory_order_acquire)) {
-            // queue is empty
-            return nullptr;
-        }
-        return &records_[currentRead];
-    }
-
-    // queue must not be empty
-    void popFront() {
-        auto const currentRead = readIndex_.load(std::memory_order_relaxed);
-        assert(currentRead != writeIndex_.load(std::memory_order_acquire));
-
-        auto nextRecord = currentRead + 1;
-        if (nextRecord == size_) {
-            nextRecord = 0;
-        }
-        records_[currentRead].~T();
-        readIndex_.store(nextRecord, std::memory_order_release);
-    }
-
-    bool isEmpty() const {
-        return readIndex_.load(std::memory_order_acquire) == writeIndex_.load(std::memory_order_acquire);
-    }
-
-    bool isFull() const {
-        auto nextRecord = writeIndex_.load(std::memory_order_acquire) + 1;
-        if (nextRecord == size_) {
-            nextRecord = 0;
-        }
-        if (nextRecord != readIndex_.load(std::memory_order_acquire)) {
-            return false;
-        }
-        // queue is full
-        return true;
-    }
-
-    // * If called by consumer, then true size may be more (because producer may
-    //   be adding items concurrently).
-    // * If called by producer, then true size may be less (because consumer may
-    //   be removing items concurrently).
-    // * It is undefined to call this from any other thread.
-    size_t sizeGuess() const {
-        int ret = writeIndex_.load(std::memory_order_acquire) - readIndex_.load(std::memory_order_acquire);
-        if (ret < 0) {
-            ret += size_;
-        }
-        return ret;
-    }
-
-    // maximum number of items in the queue.
-    size_t capacity() const { return size_ - 1; }
-
-  private:
-    using AtomicIndex = std::atomic<unsigned int>;
-
-    char pad0_[hardware_destructive_interference_size];
-    // const uint32_t size_;
-    uint32_t size_;
-    // T *const records_;
-    T* records_;
-
-    alignas(hardware_destructive_interference_size) AtomicIndex readIndex_;
-    alignas(hardware_destructive_interference_size) AtomicIndex writeIndex_;
-
-    char pad1_[hardware_destructive_interference_size - sizeof(AtomicIndex)];
-};
-
-} // namespace aare

include/aare/RawFile.hpp

@@ -34,19 +34,15 @@ class RawFile : public FileInterface {
     size_t n_subfile_parts{}; // d0,d1...dn
     //TODO! move to vector of SubFile instead of pointers
     std::vector<std::vector<RawSubFile *>> subfiles; //subfiles[f0,f1...fn][d0,d1...dn]
-    // std::vector<xy> positions;
-    
+    std::vector<xy> positions;
+    std::vector<ModuleGeometry> m_module_pixel_0;
     ModuleConfig cfg{0, 0};
 
     RawMasterFile m_master;
 
     size_t m_current_frame{};
-
-    // std::vector<ModuleGeometry> m_module_pixel_0;
-    // size_t m_rows{};
-    // size_t m_cols{};
-
-    DetectorGeometry m_geometry;
+    size_t m_rows{};
+    size_t m_cols{};
 
   public:
     /**
@@ -115,12 +111,11 @@ class RawFile : public FileInterface {
      */
     static DetectorHeader read_header(const std::filesystem::path &fname);
 
-    // void update_geometry_with_roi();
+    void update_geometry_with_roi();
     int find_number_of_subfiles();
 
     void open_subfiles();
     void find_geometry();
 };
 
-
 } // namespace aare

include/aare/RawMasterFile.hpp

@@ -62,6 +62,17 @@ class ScanParameters {
 };
 
 
+struct ROI{
+  int64_t xmin{};
+  int64_t xmax{};
+  int64_t ymin{};
+  int64_t ymax{};
+
+  int64_t height() const { return ymax - ymin; }
+  int64_t width() const { return xmax - xmin; }
+};
+
+
 /**
  * @brief Class for parsing a master file either in our .json format or the old
  * .raw format

include/aare/RawSubFile.hpp

@@ -22,7 +22,7 @@ class RawSubFile {
     size_t m_rows{};
     size_t m_cols{};
     size_t m_bytes_per_frame{};
-    size_t m_num_frames{};
+    size_t n_frames{};
     uint32_t m_pos_row{};
     uint32_t m_pos_col{};
  
@@ -53,7 +53,6 @@ class RawSubFile {
     size_t tell();
 
     void read_into(std::byte *image_buf, DetectorHeader *header = nullptr);
-    void read_into(std::byte *image_buf, size_t n_frames, DetectorHeader *header= nullptr);
     void get_part(std::byte *buffer, size_t frame_index);
     
     void read_header(DetectorHeader *header);
@@ -65,13 +64,8 @@ class RawSubFile {
 
     size_t bytes_per_frame() const { return m_bytes_per_frame; }
     size_t pixels_per_frame() const { return m_rows * m_cols; }
-    size_t bytes_per_pixel() const { return m_bitdepth / bits_per_byte; }
+    size_t bytes_per_pixel() const { return m_bitdepth / 8; }
 
-    size_t frames_in_file() const { return m_num_frames; }
-
-private:
-  template <typename T>
-  void read_with_map(std::byte *image_buf);
 
 };
 

include/aare/VarClusterFinder.hpp

@@ -7,7 +7,7 @@
 
 #include "aare/NDArray.hpp"
 
-const int MAX_CLUSTER_SIZE = 50;
+const int MAX_CLUSTER_SIZE = 200;
 namespace aare {
 
 template <typename T> class VarClusterFinder {
@@ -226,7 +226,7 @@ template <typename T> void VarClusterFinder<T>::single_pass(NDView<T, 2> img) {
 
 template <typename T> void VarClusterFinder<T>::first_pass() {
 
-    for (ssize_t i = 0; i < original_.size(); ++i) {
+    for (size_t i = 0; i < original_.size(); ++i) {
         if (use_noise_map)
             threshold_ = 5 * noiseMap(i);
         binary_(i) = (original_(i) > threshold_);
@@ -250,7 +250,7 @@ template <typename T> void VarClusterFinder<T>::first_pass() {
 
 template <typename T> void VarClusterFinder<T>::second_pass() {
 
-    for (ssize_t i = 0; i != labeled_.size(); ++i) {
+    for (size_t i = 0; i != labeled_.size(); ++i) {
         auto cl = labeled_(i);
         if (cl != 0) {
             auto it = child.find(cl);

include/aare/algorithm.hpp

@@ -1,111 +0,0 @@
-
-#pragma once
-#include <algorithm>
-#include <array>
-#include <vector>
-#include <aare/NDArray.hpp>
-
-namespace aare {
-/**
- * @brief Index of the last element that is smaller than val.
- * Requires a sorted array. Uses >= for ordering. If all elements
- * are smaller it returns the last element and if all elements are
- * larger it returns the first element.
- * @param first iterator to the first element
- * @param last iterator to the last element
- * @param val value to compare
- * @return index of the last element that is smaller than val
- * 
- */
-template <typename T>
-size_t last_smaller(const T* first, const T* last, T val) {
-    for (auto iter = first+1; iter != last; ++iter) {
-        if (*iter >= val) {
-            return std::distance(first, iter-1);
-        }
-    }
-    return std::distance(first, last-1);
-}
-
-template <typename T>
-size_t last_smaller(const NDArray<T, 1>& arr, T val) {
-    return last_smaller(arr.begin(), arr.end(), val);
-}
-
-template <typename T>
-size_t last_smaller(const std::vector<T>& vec, T val) {
-    return last_smaller(vec.data(), vec.data()+vec.size(), val);
-}
-
-/**
- * @brief Index of the first element that is larger than val.
- * Requires a sorted array. Uses > for ordering. If all elements
- * are larger it returns the first element and if all elements are
- * smaller it returns the last element.
- * @param first iterator to the first element
- * @param last iterator to the last element
- * @param val value to compare
- * @return index of the first element that is larger than val
- */
-template <typename T>
-size_t first_larger(const T* first, const T* last, T val) {
-    for (auto iter = first; iter != last; ++iter) {
-        if (*iter > val) {
-            return std::distance(first, iter);
-        }
-    }
-    return std::distance(first, last-1);
-}
-
-template <typename T>
-size_t first_larger(const NDArray<T, 1>& arr, T val) {
-    return first_larger(arr.begin(), arr.end(), val);
-}
-
-template <typename T>
-size_t first_larger(const std::vector<T>& vec, T val) {
-    return first_larger(vec.data(), vec.data()+vec.size(), val);
-}
-
-/**
- * @brief Index of the nearest element to val.
- * Requires a sorted array. If there is no difference it takes the first element.
- * @param first iterator to the first element
- * @param last iterator to the last element
- * @param val value to compare
- * @return index of the nearest element
- */
-template <typename T>
-size_t nearest_index(const T* first, const T* last, T val) {
-    auto iter = std::min_element(first, last,
-    [val](T a, T b) {
-        return std::abs(a - val) < std::abs(b - val);
-    });
-    return std::distance(first, iter);
-}
-
-template <typename T>
-size_t nearest_index(const NDArray<T, 1>& arr, T val) {
-    return nearest_index(arr.begin(), arr.end(), val);
-}
-
-template <typename T>
-size_t nearest_index(const std::vector<T>& vec, T val) {
-    return nearest_index(vec.data(), vec.data()+vec.size(), val);
-}
-
-template <typename T, size_t N>
-size_t nearest_index(const std::array<T,N>& arr, T val) {
-    return nearest_index(arr.data(), arr.data()+arr.size(), val);
-}
-
-template <typename T>
-std::vector<T> cumsum(const std::vector<T>& vec) {
-    std::vector<T> result(vec.size());
-    std::partial_sum(vec.begin(), vec.end(), result.begin());
-    return result;
-}
-
-
-
-} // namespace aare

include/aare/decode.hpp

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <vector>
-#include <aare/NDView.hpp>
-namespace aare {
-
-
-uint16_t adc_sar_05_decode64to16(uint64_t input);
-uint16_t adc_sar_04_decode64to16(uint64_t input);
-void adc_sar_05_decode64to16(NDView<uint64_t, 2> input, NDView<uint16_t,2> output);
-void adc_sar_04_decode64to16(NDView<uint64_t, 2> input, NDView<uint16_t,2> output);
-
-
-/**
- * @brief Apply custom weights to a 16-bit input value. Will sum up weights[i]**i
- * for each bit i that is set in the input value.
- * @throws std::out_of_range if weights.size() < 16
- * @param input 16-bit input value
- * @param weights vector of weights, size must be less than or equal to 16
- */
-double apply_custom_weights(uint16_t input, const NDView<double, 1> weights);
-
-void apply_custom_weights(NDView<uint16_t, 1> input, NDView<double, 1> output, const NDView<double, 1> weights);
-
-} // namespace aare

include/aare/defs.hpp

@@ -1,9 +1,11 @@
 #pragma once
 
 #include "aare/Dtype.hpp"
+// #include "aare/utils/logger.hpp"
 
 #include <array>
 #include <stdexcept>
+
 #include <cassert>
 #include <cstdint>
 #include <cstring>
@@ -36,19 +38,16 @@
 
 namespace aare {
 
-inline constexpr size_t bits_per_byte = 8;
-
 void assert_failed(const std::string &msg);
 
 
-
 class DynamicCluster {
   public:
     int cluster_sizeX;
     int cluster_sizeY;
     int16_t x;
     int16_t y;
-    Dtype dt; // 4 bytes
+    Dtype dt;
 
   private:
     std::byte *m_data;
@@ -180,45 +179,13 @@ template <typename T> struct t_xy {
 using xy = t_xy<uint32_t>;
 
 
-/**
- * @brief Class to hold the geometry of a module. Where pixel 0 is located and the size of the module
- */
 struct ModuleGeometry{
-    int origin_x{};
-    int origin_y{};
+    int x{};
+    int y{};
     int height{};
     int width{};
-    int row_index{};
-    int col_index{}; 
 };
 
-/**
- * @brief Class to hold the geometry of a detector. Number of modules, their size and where pixel 0 
- * for each module is located
- */
-struct DetectorGeometry{
-    int modules_x{};
-    int modules_y{};
-    int pixels_x{};
-    int pixels_y{};
-    int module_gap_row{};
-    int module_gap_col{};
-    std::vector<ModuleGeometry> module_pixel_0;
-};
-
-struct ROI{
-    int64_t xmin{};
-    int64_t xmax{};
-    int64_t ymin{};
-    int64_t ymax{};
-  
-    int64_t height() const { return ymax - ymin; }
-    int64_t width() const { return xmax - xmin; }
-    bool contains(int64_t x, int64_t y) const {
-        return x >= xmin && x < xmax && y >= ymin && y < ymax;
-    }
-  };
-
 
 using dynamic_shape = std::vector<int64_t>;
 

include/aare/geo_helpers.hpp

@@ -1,16 +0,0 @@
-#pragma once
-#include "aare/defs.hpp"
-#include "aare/RawMasterFile.hpp" //ROI refactor away
-namespace aare{
-
-/**
- * @brief Update the detector geometry given a region of interest
- * 
- * @param geo 
- * @param roi 
- * @return DetectorGeometry 
- */
-DetectorGeometry update_geometry_with_roi(DetectorGeometry geo, ROI roi);
-
-
-} // namespace aare

include/aare/utils/ifstream_helpers.hpp

@@ -1,12 +0,0 @@
-#pragma once
-
-#include <fstream>
-#include <string>
-namespace aare {
-
-/** 
- * @brief Get the error message from an ifstream object
-*/
-std::string ifstream_error_msg(std::ifstream &ifs);
-
-} // namespace aare

include/aare/utils/par.hpp

@@ -1,18 +0,0 @@
-#include <thread>
-#include <vector>
-#include <utility>
-
-namespace aare {
-
-    template<typename F>
-    void RunInParallel(F func, const std::vector<std::pair<int, int>>& tasks) {
-        // auto tasks = split_task(0, y.shape(0), n_threads);
-        std::vector<std::thread> threads;
-        for (auto &task : tasks) {
-            threads.push_back(std::thread(func, task.first, task.second));
-        }
-        for (auto &thread : threads) {
-            thread.join();
-        }
-    }
-} // namespace aare

include/aare/utils/task.hpp

@@ -1,8 +0,0 @@
-
-#include <utility>
-#include <vector>
-
-namespace aare {
-std::vector<std::pair<int, int>> split_task(int first, int last, int n_threads);
-
-} // namespace aare

patches/libzmq_cmake_version.patch

@@ -1,18 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index dd3d8eb9..c0187747 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -1,11 +1,8 @@
- # CMake build script for ZeroMQ
- project(ZeroMQ)
- 
--if(${CMAKE_SYSTEM_NAME} STREQUAL Darwin)
--  cmake_minimum_required(VERSION 3.0.2)
--else()
--  cmake_minimum_required(VERSION 2.8.12)
--endif()
-+cmake_minimum_required(VERSION 3.15)
-+message(STATUS "Patched cmake version")
- 
- include(CheckIncludeFiles)
- include(CheckCCompilerFlag)

patches/lmfit.patch

@@ -1,13 +0,0 @@
-diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
-index 4efb7ed..6533660 100644
---- a/lib/CMakeLists.txt
-+++ b/lib/CMakeLists.txt
-@@ -11,7 +11,7 @@ target_compile_definitions(${lib} PRIVATE "LMFIT_EXPORT") # for Windows DLL expo
- 
- target_include_directories(${lib}
-     PUBLIC
--    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/>
-+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/>
-     $<INSTALL_INTERFACE:include/>
-     )
- 

pyproject.toml

@@ -4,32 +4,12 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "aare"
-version = "2025.4.22"
-requires-python = ">=3.11"
-dependencies = [
-    "numpy",
-    "matplotlib",
-]
-
-
-[tool.cibuildwheel]
-
-build = "cp{311,312,313}-manylinux_x86_64"
-
-
-
+version = "2024.11.28.dev0"
 
 [tool.scikit-build]
-build.verbose = true
-cmake.build-type = "Release"
-install.components = ["python"]
+cmake.verbose = true
 
 [tool.scikit-build.cmake.define]
 AARE_PYTHON_BINDINGS = "ON"
-AARE_INSTALL_PYTHONEXT = "ON"
-
-
-[tool.pytest.ini_options]
-markers = [
-    "files: marks tests that need additional data (deselect with '-m \"not files\"')",
-]
+AARE_SYSTEM_LIBRARIES = "ON"
+AARE_INSTALL_PYTHONEXT = "ON"

python/CMakeLists.txt

@@ -1,13 +1,12 @@
 
-find_package (Python 3.10 COMPONENTS Interpreter Development.Module REQUIRED)
-set(PYBIND11_FINDPYTHON ON) # Needed for RH8
+find_package (Python 3.10 COMPONENTS Interpreter Development REQUIRED)
 
 # Download or find pybind11 depending on configuration
 if(AARE_FETCH_PYBIND11)
     FetchContent_Declare(
         pybind11
         GIT_REPOSITORY https://github.com/pybind/pybind11
-        GIT_TAG        v2.13.6
+        GIT_TAG        v2.13.0
     )
     FetchContent_MakeAvailable(pybind11)
 else()
@@ -29,7 +28,6 @@ target_link_libraries(_aare PRIVATE aare_core aare_compiler_flags)
 set( PYTHON_FILES
     aare/__init__.py
     aare/CtbRawFile.py
-    aare/func.py
     aare/RawFile.py
     aare/transform.py
     aare/ScanParameters.py
@@ -45,30 +43,17 @@ set_target_properties(_aare PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/aare
 )
 
-set(PYTHON_EXAMPLES
-    examples/play.py
-    examples/fits.py
-)
 
 
-# Copy the python examples to the build directory
-foreach(FILE ${PYTHON_EXAMPLES})
-    configure_file(${FILE} ${CMAKE_BINARY_DIR}/${FILE}  )
-    message(STATUS "Copying ${FILE} to ${CMAKE_BINARY_DIR}/${FILE}")
-endforeach(FILE ${PYTHON_EXAMPLES})
+# Copy the examples/scripts to the build directory
+configure_file(examples/play.py ${CMAKE_BINARY_DIR}/play.py)
 
 
 if(AARE_INSTALL_PYTHONEXT)
-    install(
-        TARGETS _aare
+    install(TARGETS _aare
         EXPORT "${TARGETS_EXPORT_NAME}"
         LIBRARY DESTINATION aare
-        COMPONENT python
     )
 
-    install(
-        FILES ${PYTHON_FILES} 
-        DESTINATION aare
-        COMPONENT python
-        )
+    install(FILES ${PYTHON_FILES} DESTINATION aare)
 endif()

python/aare/__init__.py

@@ -2,27 +2,13 @@
 from . import _aare
 
 
-from ._aare import File, RawMasterFile, RawSubFile, JungfrauDataFile
-from ._aare import Pedestal_d, Pedestal_f, ClusterFinder, VarClusterFinder
+from ._aare import File, RawMasterFile, RawSubFile
+from ._aare import Pedestal, ClusterFinder, VarClusterFinder
 from ._aare import DetectorType
 from ._aare import ClusterFile
-from ._aare import hitmap
-from ._aare import ROI
-
-from ._aare import ClusterFinderMT, ClusterCollector, ClusterFileSink, ClusterVector_i
-
-from ._aare import fit_gaus, fit_pol1
-from ._aare import Interpolator
-
-
-from ._aare import apply_custom_weights
 
 from .CtbRawFile import CtbRawFile
 from .RawFile import RawFile
 from .ScanParameters import ScanParameters
 
-from .utils import random_pixels, random_pixel, flat_list, add_colorbar
-
-
-#make functions available in the top level API
-from .func import *
+from .utils import random_pixels, random_pixel

python/aare/func.py

@@ -1 +0,0 @@
-from ._aare import gaus, pol1

python/aare/transform.py

@@ -2,14 +2,6 @@ import numpy as np
 from . import _aare
 
 
-class AdcSar04Transform64to16:
-    def __call__(self, data):
-        return _aare.adc_sar_04_decode64to16(data)
-
-class AdcSar05Transform64to16:
-    def __call__(self, data):
-        return _aare.adc_sar_05_decode64to16(data)
-
 class Moench05Transform:
     #Could be moved to C++ without changing the interface
     def __init__(self):
@@ -53,6 +45,4 @@ class Matterhorn02Transform:
 moench05 = Moench05Transform()
 moench05_1g = Moench05Transform1g()
 moench05_old = Moench05TransformOld()
-matterhorn02 = Matterhorn02Transform()
-adc_sar_04_64to16 = AdcSar04Transform64to16()
-adc_sar_05_64to16 = AdcSar05Transform64to16()
+matterhorn02 = Matterhorn02Transform()

python/aare/utils.py

@@ -1,6 +1,4 @@
 import numpy as np
-import matplotlib.pyplot as plt
-from mpl_toolkits.axes_grid1 import make_axes_locatable
 
 def random_pixels(n_pixels, xmin=0, xmax=512, ymin=0, ymax=1024):
     """Return a list of random pixels.
@@ -22,15 +20,4 @@ def random_pixel(xmin=0, xmax=512, ymin=0, ymax=1024):
     Returns:
         tuple: (row, col)
     """
-    return random_pixels(1, xmin, xmax, ymin, ymax)[0]
-
-def flat_list(xss):
-    """Flatten a list of lists."""
-    return [x for xs in xss for x in xs]
-
-def add_colorbar(ax, im, size="5%", pad=0.05):
-    """Add a colorbar with the same height as the image."""
-    divider = make_axes_locatable(ax)
-    cax = divider.append_axes("right", size=size, pad=pad)
-    plt.colorbar(im, cax=cax)
-    return ax, im, cax
+    return random_pixels(1, xmin, xmax, ymin, ymax)[0]

python/examples/fits.py

@@ -1,79 +0,0 @@
-import matplotlib.pyplot as plt
-import numpy as np
-from aare import fit_gaus, fit_pol1
-from aare import gaus, pol1
-
-textpm = f"±"  #
-textmu = f"μ"  #
-textsigma = f"σ"  #
-
-
-
-# ================================= Gauss fit =================================
-# Parameters
-mu = np.random.uniform(1, 100)  # Mean of Gaussian
-sigma = np.random.uniform(4, 20)  # Standard deviation
-num_points = 10000  # Number of points for smooth distribution
-noise_sigma = 100
-
-# Generate Gaussian distribution
-data = np.random.normal(mu, sigma, num_points)
-
-# Generate errors for each point
-errors = np.abs(np.random.normal(0, sigma, num_points))  # Errors with mean 0, std 0.5
-
-# Create subplot
-fig0, ax0 = plt.subplots(1, 1, num=0, figsize=(12, 8))
-
-x = np.histogram(data, bins=30)[1][:-1] + 0.05
-y = np.histogram(data, bins=30)[0]
-yerr = errors[:30]
-
-
-# Add the errors as error bars in the step plot
-ax0.errorbar(x, y, yerr=yerr, fmt=". ", capsize=5)
-ax0.grid()
-
-par, err = fit_gaus(x, y, yerr)
-print(par, err)
-
-x = np.linspace(x[0], x[-1], 1000)
-ax0.plot(x, gaus(x, par), marker="")
-ax0.set(xlabel="x", ylabel="Counts", title=f"A0 = {par[0]:0.2f}{textpm}{err[0]:0.2f}\n"
-                                           f"{textmu} = {par[1]:0.2f}{textpm}{err[1]:0.2f}\n"
-                                           f"{textsigma} = {par[2]:0.2f}{textpm}{err[2]:0.2f}\n"
-                                           f"(init: {textmu}: {mu:0.2f}, {textsigma}: {sigma:0.2f})")
-fig0.tight_layout()
-
-
-
-# ================================= pol1 fit =================================
-# Parameters
-n_points = 40
-
-# Generate random slope and intercept (origin)
-slope = np.random.uniform(-10, 10)  # Random slope between 0.5 and 2.0
-intercept = np.random.uniform(-10, 10)  # Random intercept between -10 and 10
-
-# Generate random x values
-x_values = np.random.uniform(-10, 10, n_points)
-
-# Calculate y values based on the linear function y = mx + b + error
-errors = np.abs(np.random.normal(0, np.random.uniform(1, 5), n_points))
-var_points = np.random.normal(0, np.random.uniform(0.1, 2), n_points)
-y_values = slope * x_values + intercept + var_points
-
-fig1, ax1 = plt.subplots(1, 1, num=1, figsize=(12, 8))
-ax1.errorbar(x_values, y_values, yerr=errors, fmt=". ", capsize=5)
-par, err = fit_pol1(x_values, y_values, errors)
-
-
-x = np.linspace(np.min(x_values), np.max(x_values), 1000)
-ax1.plot(x, pol1(x, par), marker="")
-ax1.set(xlabel="x", ylabel="y", title=f"a = {par[0]:0.2f}{textpm}{err[0]:0.2f}\n"
-                                      f"b = {par[1]:0.2f}{textpm}{err[1]:0.2f}\n"
-                                      f"(init: {slope:0.2f}, {intercept:0.2f})")
-fig1.tight_layout()
-
-plt.show()
-

python/examples/play.py

@@ -1,79 +1,15 @@
-import sys
-sys.path.append('/home/l_msdetect/erik/aare/build')
-
-from aare._aare import ClusterVector_i, Interpolator
-
-import pickle 
-import numpy as np
 import matplotlib.pyplot as plt
-import boost_histogram as bh
-import torch
-import math
-import time
+import numpy as np
+plt.ion()
+from pathlib import Path
+from aare import ClusterFile
+
+base = Path('~/data/aare_test_data/clusters').expanduser()
+
+f = ClusterFile(base / 'beam_En700eV_-40deg_300V_10us_d0_f0_100.clust')
+# f = ClusterFile(base / 'single_frame_97_clustrers.clust')
 
 
-
-def gaussian_2d(mx, my, sigma = 1, res=100, grid_size = 2):
-    """
-    Generate a 2D gaussian as position mx, my, with sigma=sigma. 
-    The gaussian is placed on a 2x2 pixel matrix with resolution 
-    res in one dimesion.
-    """
-    x = torch.linspace(0, pixel_size*grid_size, res)
-    x,y = torch.meshgrid(x,x, indexing="ij")
-    return 1 / (2*math.pi*sigma**2) * \
-      torch.exp(-((x - my)**2 / (2*sigma**2) + (y - mx)**2 / (2*sigma**2)))
-
-scale = 1000 #Scale factor when converting to integer
-pixel_size = 25 #um
-grid = 2
-resolution = 100
-sigma_um = 10
-xa = np.linspace(0,grid*pixel_size,resolution)
-ticks = [0, 25, 50]
-
-hit = np.array((20,20))
-etahist_fname = "/home/l_msdetect/erik/tmp/test_hist.pkl"
-
-local_resolution = 99
-grid_size = 3
-xaxis = np.linspace(0,grid_size*pixel_size, local_resolution)
-t = gaussian_2d(hit[0],hit[1], grid_size = grid_size, sigma = 10, res = local_resolution)
-pixels = t.reshape(grid_size, t.shape[0] // grid_size, grid_size, t.shape[1] // grid_size).sum(axis = 3).sum(axis = 1)
-pixels = pixels.numpy()
-pixels = (pixels*scale).astype(np.int32)
-v = ClusterVector_i(3,3)
-v.push_back(1,1, pixels)
-
-with open(etahist_fname, "rb") as f:
-        hist = pickle.load(f)
-eta = hist.view().copy()
-etabinsx = np.array(hist.axes.edges.T[0].flat)
-etabinsy = np.array(hist.axes.edges.T[1].flat)
-ebins = np.array(hist.axes.edges.T[2].flat)
-p = Interpolator(eta, etabinsx[0:-1], etabinsy[0:-1], ebins[0:-1])
-
-
-
-
-#Generate the hit
-
-
-
-
-tmp = p.interpolate(v)
-print(f'tmp:{tmp}')
-pos = np.array((tmp['x'], tmp['y']))*25
-
-
-print(pixels)
-fig, ax = plt.subplots(figsize = (7,7))
-ax.pcolormesh(xaxis, xaxis, t)
-ax.plot(*pos, 'o')
-ax.set_xticks([0,25,50,75])
-ax.set_yticks([0,25,50,75])
-ax.set_xlim(0,75)
-ax.set_ylim(0,75)
-ax.grid()
-print(f'{hit=}')
-print(f'{pos=}')
+for i in range(10):
+    fn, cl = f.read_frame()
+    print(fn, cl.size)

python/src/cluster.hpp

@@ -1,8 +1,4 @@
-#include "aare/ClusterCollector.hpp"
-#include "aare/ClusterFileSink.hpp"
 #include "aare/ClusterFinder.hpp"
-#include "aare/ClusterFinderMT.hpp"
-#include "aare/ClusterVector.hpp"
 #include "aare/NDView.hpp"
 #include "aare/Pedestal.hpp"
 #include "np_helper.hpp"
@@ -11,184 +7,31 @@
 #include <filesystem>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
 
 namespace py = pybind11;
-using pd_type = double;
-
-template <typename T>
-void define_cluster_vector(py::module &m, const std::string &typestr) {
-    auto class_name = fmt::format("ClusterVector_{}", typestr);
-    py::class_<ClusterVector<T>>(m, class_name.c_str(), py::buffer_protocol())
-        .def(py::init<int, int>(),
-    py::arg("cluster_size_x") = 3, py::arg("cluster_size_y") = 3)
-        .def("push_back",
-             [](ClusterVector<T> &self, int x, int y, py::array_t<T> data) {
-                //  auto view = make_view_2d(data);
-                 self.push_back(x, y, reinterpret_cast<const std::byte*>(data.data()));
-             })
-        .def_property_readonly("size", &ClusterVector<T>::size)
-        .def("item_size", &ClusterVector<T>::item_size)
-        .def_property_readonly("fmt",
-                               [typestr](ClusterVector<T> &self) {
-                                   return fmt::format(
-                                       self.fmt_base(), self.cluster_size_x(),
-                                       self.cluster_size_y(), typestr);
-                               })
-        .def("sum",
-             [](ClusterVector<T> &self) {
-                 auto *vec = new std::vector<T>(self.sum());
-                 return return_vector(vec);
-             })
-        .def("sum_2x2", [](ClusterVector<T> &self) {
-            auto *vec = new std::vector<T>(self.sum_2x2());
-            return return_vector(vec);
-        })
-        .def_property_readonly("cluster_size_x", &ClusterVector<T>::cluster_size_x)
-        .def_property_readonly("cluster_size_y", &ClusterVector<T>::cluster_size_y)
-        .def_property_readonly("capacity", &ClusterVector<T>::capacity)
-        .def_property("frame_number", &ClusterVector<T>::frame_number,
-                      &ClusterVector<T>::set_frame_number)
-        .def_buffer([typestr](ClusterVector<T> &self) -> py::buffer_info {
-            return py::buffer_info(
-                self.data(),      /* Pointer to buffer */
-                self.item_size(), /* Size of one scalar */
-                fmt::format(self.fmt_base(), self.cluster_size_x(),
-                            self.cluster_size_y(),
-                            typestr), /* Format descriptor */
-                1,                    /* Number of dimensions */
-                {self.size()},        /* Buffer dimensions */
-                {self.item_size()}    /* Strides (in bytes) for each index */
-            );
-        });
-}
-
-void define_cluster_finder_mt_bindings(py::module &m) {
-    py::class_<ClusterFinderMT<uint16_t, pd_type>>(m, "ClusterFinderMT")
-        .def(py::init<Shape<2>, Shape<2>, pd_type, size_t, size_t>(),
-             py::arg("image_size"), py::arg("cluster_size"),
-             py::arg("n_sigma") = 5.0, py::arg("capacity") = 2048,
-             py::arg("n_threads") = 3)
-        .def("push_pedestal_frame",
-             [](ClusterFinderMT<uint16_t, pd_type> &self,
-                py::array_t<uint16_t> frame) {
-                 auto view = make_view_2d(frame);
-                 self.push_pedestal_frame(view);
-             })
-        .def(
-            "find_clusters",
-            [](ClusterFinderMT<uint16_t, pd_type> &self,
-               py::array_t<uint16_t> frame, uint64_t frame_number) {
-                auto view = make_view_2d(frame);
-                self.find_clusters(view, frame_number);
-                return;
-            },
-            py::arg(), py::arg("frame_number") = 0)
-        .def("clear_pedestal", &ClusterFinderMT<uint16_t, pd_type>::clear_pedestal)
-        .def("sync", &ClusterFinderMT<uint16_t, pd_type>::sync)
-        .def("stop", &ClusterFinderMT<uint16_t, pd_type>::stop)
-        .def("start", &ClusterFinderMT<uint16_t, pd_type>::start)
-        .def("pedestal",
-             [](ClusterFinderMT<uint16_t, pd_type> &self, size_t thread_index) {
-                 auto pd = new NDArray<pd_type, 2>{};
-                 *pd = self.pedestal(thread_index);
-                 return return_image_data(pd);
-             },py::arg("thread_index") = 0)
-        .def("noise",
-             [](ClusterFinderMT<uint16_t, pd_type> &self, size_t thread_index) {
-                 auto arr = new NDArray<pd_type, 2>{};
-                 *arr = self.noise(thread_index);
-                 return return_image_data(arr);
-             },py::arg("thread_index") = 0);
-}
-
-void define_cluster_collector_bindings(py::module &m) {
-    py::class_<ClusterCollector>(m, "ClusterCollector")
-        .def(py::init<ClusterFinderMT<uint16_t, double, int32_t> *>())
-        .def("stop", &ClusterCollector::stop)
-        .def(
-            "steal_clusters",
-            [](ClusterCollector &self) {
-                auto v =
-                    new std::vector<ClusterVector<int>>(self.steal_clusters());
-                return v;
-            },
-            py::return_value_policy::take_ownership);
-}
-
-void define_cluster_file_sink_bindings(py::module &m) {
-    py::class_<ClusterFileSink>(m, "ClusterFileSink")
-        .def(py::init<ClusterFinderMT<uint16_t, double, int32_t> *,
-                      const std::filesystem::path &>())
-        .def("stop", &ClusterFileSink::stop);
-}
 
 void define_cluster_finder_bindings(py::module &m) {
-    py::class_<ClusterFinder<uint16_t, pd_type>>(m, "ClusterFinder")
-        .def(py::init<Shape<2>, Shape<2>, pd_type, size_t>(),
-             py::arg("image_size"), py::arg("cluster_size"),
-             py::arg("n_sigma") = 5.0, py::arg("capacity") = 1'000'000)
+    py::class_<ClusterFinder<uint16_t, double>>(m, "ClusterFinder")
+        .def(py::init<Shape<2>, Shape<2>>())
         .def("push_pedestal_frame",
-             [](ClusterFinder<uint16_t, pd_type> &self,
+             [](ClusterFinder<uint16_t, double> &self,
                 py::array_t<uint16_t> frame) {
                  auto view = make_view_2d(frame);
                  self.push_pedestal_frame(view);
              })
-        .def("clear_pedestal", &ClusterFinder<uint16_t, pd_type>::clear_pedestal)
-        .def_property_readonly("pedestal",
-                               [](ClusterFinder<uint16_t, pd_type> &self) {
-                                   auto pd = new NDArray<pd_type, 2>{};
-                                   *pd = self.pedestal();
-                                   return return_image_data(pd);
-                               })
-        .def_property_readonly("noise",
-                               [](ClusterFinder<uint16_t, pd_type> &self) {
-                                   auto arr = new NDArray<pd_type, 2>{};
-                                   *arr = self.noise();
-                                   return return_image_data(arr);
-                               })
-        .def(
-            "steal_clusters",
-            [](ClusterFinder<uint16_t, pd_type> &self,
-               bool realloc_same_capacity) {
-                auto v = new ClusterVector<int>(
-                    self.steal_clusters(realloc_same_capacity));
-                return v;
-            },
-            py::arg("realloc_same_capacity") = false)
-        .def(
-            "find_clusters",
-            [](ClusterFinder<uint16_t, pd_type> &self,
-               py::array_t<uint16_t> frame, uint64_t frame_number) {
-                auto view = make_view_2d(frame);
-                self.find_clusters(view, frame_number);
-                return;
-            },
-            py::arg(), py::arg("frame_number") = 0);
-
-    m.def("hitmap",
-          [](std::array<size_t, 2> image_size, ClusterVector<int32_t> &cv) {
-              py::array_t<int32_t> hitmap(image_size);
-              auto r = hitmap.mutable_unchecked<2>();
-
-              // Initialize hitmap to 0
-              for (py::ssize_t i = 0; i < r.shape(0); i++)
-                  for (py::ssize_t j = 0; j < r.shape(1); j++)
-                      r(i, j) = 0;
-
-              size_t stride = cv.item_size();
-              auto ptr = cv.data();
-              for (size_t i = 0; i < cv.size(); i++) {
-                  auto x = *reinterpret_cast<int16_t *>(ptr);
-                  auto y = *reinterpret_cast<int16_t *>(ptr + sizeof(int16_t));
-                  r(y, x) += 1;
-                  ptr += stride;
-              }
-              return hitmap;
-          });
-    define_cluster_vector<int>(m, "i");
-    define_cluster_vector<double>(m, "d");
-    define_cluster_vector<float>(m, "f");
+        .def("pedestal",
+             [](ClusterFinder<uint16_t, double> &self) {
+                 auto pd = new NDArray<double, 2>{};
+                 *pd = self.pedestal();
+                 return return_image_data(pd);
+             })
+        .def("find_clusters_without_threshold",
+             [](ClusterFinder<uint16_t, double> &self,
+                py::array_t<uint16_t> frame) {
+                 auto view = make_view_2d(frame);
+                 auto clusters = self.find_clusters_without_threshold(view);
+                 return clusters;
+             });
 
     py::class_<DynamicCluster>(m, "DynamicCluster", py::buffer_protocol())
         .def(py::init<int, int, Dtype>())

python/src/cluster_file.hpp

@@ -1,6 +1,7 @@
 #include "aare/ClusterFile.hpp"
 #include "aare/defs.hpp"
 
+
 #include <cstdint>
 #include <filesystem>
 #include <pybind11/iostream.h>
@@ -10,64 +11,40 @@
 #include <pybind11/stl/filesystem.h>
 #include <string>
 
-//Disable warnings for unused parameters, as we ignore some
-//in the __exit__ method
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-
-
 namespace py = pybind11;
 using namespace ::aare;
 
 void define_cluster_file_io_bindings(py::module &m) {
-    PYBIND11_NUMPY_DTYPE(Cluster3x3, x, y, data);
+    PYBIND11_NUMPY_DTYPE(Cluster, x, y, data);
 
     py::class_<ClusterFile>(m, "ClusterFile")
-        .def(py::init<const std::filesystem::path &, size_t,
-                      const std::string &>(),
-             py::arg(), py::arg("chunk_size") = 1000, py::arg("mode") = "r")
+        .def(py::init<const std::filesystem::path &, size_t>(), py::arg(), py::arg("chunk_size") = 1000)
         .def("read_clusters",
              [](ClusterFile &self, size_t n_clusters) {
-                auto v = new ClusterVector<int32_t>(self.read_clusters(n_clusters));
-                return v;
-             },py::return_value_policy::take_ownership)
+                 auto* vec = new std::vector<Cluster>(self.read_clusters(n_clusters));
+                 return return_vector(vec);
+             })
         .def("read_frame",
              [](ClusterFile &self) {
-                auto v = new ClusterVector<int32_t>(self.read_frame());
-                return v;
+                 int32_t frame_number;
+                 auto* vec = new std::vector<Cluster>(self.read_frame(frame_number));
+                 return py::make_tuple(frame_number, return_vector(vec));
+             })
+        .def("read_cluster_with_cut",
+             [](ClusterFile &self, size_t n_clusters, py::array_t<double> noise_map, int nx, int ny) {
+                 auto view = make_view_2d(noise_map);
+                 auto* vec = new std::vector<Cluster>(self.read_cluster_with_cut(n_clusters, view.data(), nx, ny));
+                 return return_vector(vec);
              })
-        .def("set_roi", &ClusterFile::set_roi)
-        .def("set_noise_map", [](ClusterFile &self, py::array_t<int32_t> noise_map) {
-            auto view = make_view_2d(noise_map);
-            self.set_noise_map(view);
-        })
-        .def("set_gain_map", [](ClusterFile &self, py::array_t<double> gain_map) {
-            auto view = make_view_2d(gain_map);
-            self.set_gain_map(view);
-        })
-        .def("close", &ClusterFile::close)
-        .def("write_frame", &ClusterFile::write_frame)
         .def("__enter__", [](ClusterFile &self) { return &self; })
-        .def("__exit__",
-             [](ClusterFile &self,
-                const std::optional<pybind11::type> &exc_type,
-                const std::optional<pybind11::object> &exc_value,
-                const std::optional<pybind11::object> &traceback) {
-                 self.close();
-             })
+        .def("__exit__", [](ClusterFile &self) {  self.close();})
         .def("__iter__", [](ClusterFile &self) { return &self; })
         .def("__next__", [](ClusterFile &self) {
-            auto v = new ClusterVector<int32_t>(self.read_clusters(self.chunk_size()));
-            if (v->size() == 0) {
+            auto vec =  new std::vector<Cluster>(self.read_clusters(self.chunk_size()));
+            if(vec->size() == 0) {
                 throw py::stop_iteration();
             }
-            return v;
+            return return_vector(vec);
         });
 
-        m.def("calculate_eta2", []( aare::ClusterVector<int32_t> &clusters) {
-            auto eta2 = new NDArray<double, 2>(calculate_eta2(clusters));
-            return return_image_data(eta2);
-        });
-}
-
-#pragma GCC diagnostic pop
+}

python/src/ctb_raw_file.hpp

@@ -7,11 +7,8 @@
 #include "aare/RawSubFile.hpp"
 
 #include "aare/defs.hpp"
-#include "aare/decode.hpp"
 // #include "aare/fClusterFileV2.hpp"
 
-#include "np_helper.hpp"
-
 #include <cstdint>
 #include <filesystem>
 #include <pybind11/iostream.h>
@@ -26,95 +23,35 @@ using namespace ::aare;
 
 void define_ctb_raw_file_io_bindings(py::module &m) {
 
-m.def("adc_sar_05_decode64to16", [](py::array_t<uint8_t> input) {
+ py::class_<CtbRawFile>(m, "CtbRawFile")
+        .def(py::init<const std::filesystem::path &>())
+        .def("read_frame",
+             [](CtbRawFile &self) {
+                 size_t image_size = self.image_size_in_bytes();
+                 py::array image;
+                 std::vector<ssize_t> shape;
+                 shape.reserve(2);
+                 shape.push_back(1);
+                 shape.push_back(image_size);
 
-    
-    if(input.ndim() != 2){
-        throw std::runtime_error("Only 2D arrays are supported at this moment"); 
-    }
+                 py::array_t<DetectorHeader> header(1);
 
-    //Create a 2D output array with the same shape as the input
-    std::vector<ssize_t> shape{input.shape(0), input.shape(1)/static_cast<int64_t>(bits_per_byte)};
-    py::array_t<uint16_t> output(shape);
+                 // always read bytes
+                 image = py::array_t<uint8_t>(shape);
 
-    //Create a view of the input and output arrays
-    NDView<uint64_t, 2> input_view(reinterpret_cast<uint64_t*>(input.mutable_data()), {output.shape(0), output.shape(1)});
-    NDView<uint16_t, 2> output_view(output.mutable_data(), {output.shape(0), output.shape(1)});
+                 self.read_into(
+                     reinterpret_cast<std::byte *>(image.mutable_data()),
+                     header.mutable_data());
 
-    adc_sar_05_decode64to16(input_view, output_view);
+                 return py::make_tuple(header, image);
+             })
+        .def("seek", &CtbRawFile::seek)
+        .def("tell", &CtbRawFile::tell)
+        .def("master", &CtbRawFile::master)
 
-    return output;
-});
+        .def_property_readonly("image_size_in_bytes",
+                               &CtbRawFile::image_size_in_bytes)
 
+        .def_property_readonly("frames_in_file", &CtbRawFile::frames_in_file);
 
-m.def("adc_sar_04_decode64to16", [](py::array_t<uint8_t> input) {
-
-    
-    if(input.ndim() != 2){
-        throw std::runtime_error("Only 2D arrays are supported at this moment"); 
-    }
-
-    //Create a 2D output array with the same shape as the input
-    std::vector<ssize_t> shape{input.shape(0), input.shape(1)/static_cast<int64_t>(bits_per_byte)};
-    py::array_t<uint16_t> output(shape);
-
-    //Create a view of the input and output arrays
-    NDView<uint64_t, 2> input_view(reinterpret_cast<uint64_t*>(input.mutable_data()), {output.shape(0), output.shape(1)});
-    NDView<uint16_t, 2> output_view(output.mutable_data(), {output.shape(0), output.shape(1)});
-
-    adc_sar_04_decode64to16(input_view, output_view);
-
-    return output;
-});
-
-m.def(
-    "apply_custom_weights",
-    [](py::array_t<uint16_t, py::array::c_style | py::array::forcecast> &input,
-       py::array_t<double, py::array::c_style | py::array::forcecast>
-           &weights) {
-        
-
-        // Create new array with same shape as the input array (uninitialized values)
-        py::buffer_info buf = input.request();
-        py::array_t<double> output(buf.shape);
-
-        // Use NDViews to call into the C++ library
-        auto weights_view = make_view_1d(weights);
-        NDView<uint16_t, 1> input_view(input.mutable_data(), {input.size()});
-        NDView<double, 1> output_view(output.mutable_data(), {output.size()});
-
-        apply_custom_weights(input_view, output_view, weights_view);
-        return output;
-    });
-
-py::class_<CtbRawFile>(m, "CtbRawFile")
-    .def(py::init<const std::filesystem::path &>())
-    .def("read_frame",
-         [](CtbRawFile &self) {
-             size_t image_size = self.image_size_in_bytes();
-             py::array image;
-             std::vector<ssize_t> shape;
-             shape.reserve(2);
-             shape.push_back(1);
-             shape.push_back(image_size);
-
-             py::array_t<DetectorHeader> header(1);
-
-             // always read bytes
-             image = py::array_t<uint8_t>(shape);
-
-             self.read_into(reinterpret_cast<std::byte *>(image.mutable_data()),
-                            header.mutable_data());
-
-             return py::make_tuple(header, image);
-         })
-    .def("seek", &CtbRawFile::seek)
-    .def("tell", &CtbRawFile::tell)
-    .def("master", &CtbRawFile::master)
-
-    .def_property_readonly("image_size_in_bytes",
-                           &CtbRawFile::image_size_in_bytes)
-
-    .def_property_readonly("frames_in_file", &CtbRawFile::frames_in_file);
-
-}
+}

python/src/file.hpp

@@ -20,14 +20,6 @@
 namespace py = pybind11;
 using namespace ::aare;
 
-
-
-
-//Disable warnings for unused parameters, as we ignore some
-//in the __exit__ method
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-
 void define_file_io_bindings(py::module &m) {
 
 
@@ -59,8 +51,7 @@ void define_file_io_bindings(py::module &m) {
         .def(py::init<const std::filesystem::path &, const std::string &,
                       const FileConfig &>())
 
-        .def("frame_number", py::overload_cast<>(&File::frame_number))
-        .def("frame_number", py::overload_cast<size_t>(&File::frame_number))
+        .def("frame_number", &File::frame_number)
         .def_property_readonly("bytes_per_frame", &File::bytes_per_frame)
         .def_property_readonly("pixels_per_frame", &File::pixels_per_frame)
         .def("seek", &File::seek)
@@ -132,41 +123,8 @@ void define_file_io_bindings(py::module &m) {
             self.read_into(reinterpret_cast<std::byte *>(image.mutable_data()),
                            n_frames);
             return image;
-        })
-        .def("__enter__", [](File &self) { return &self; })
-        .def("__exit__",
-             [](File &self,
-                const std::optional<pybind11::type> &exc_type,
-                const std::optional<pybind11::object> &exc_value,
-                const std::optional<pybind11::object> &traceback) {
-                //  self.close();
-             })
-        .def("__iter__", [](File &self) { return &self; })
-        .def("__next__", [](File &self) {
-
-            try{
-                const uint8_t item_size = self.bytes_per_pixel();
-                 py::array image;
-                 std::vector<ssize_t> shape;
-                 shape.reserve(2);
-                 shape.push_back(self.rows());
-                 shape.push_back(self.cols());
-                 if (item_size == 1) {
-                     image = py::array_t<uint8_t>(shape);
-                 } else if (item_size == 2) {
-                     image = py::array_t<uint16_t>(shape);
-                 } else if (item_size == 4) {
-                     image = py::array_t<uint32_t>(shape);
-                 }
-                 self.read_into(
-                     reinterpret_cast<std::byte *>(image.mutable_data()));
-                 return image;
-            }catch(std::runtime_error &e){
-                throw py::stop_iteration();
-            }
         });
 
-
     py::class_<FileConfig>(m, "FileConfig")
         .def(py::init<>())
         .def_readwrite("rows", &FileConfig::rows)
@@ -198,8 +156,6 @@ void define_file_io_bindings(py::module &m) {
 
     py::class_<ROI>(m, "ROI")
         .def(py::init<>())
-        .def(py::init<int64_t, int64_t, int64_t, int64_t>(), py::arg("xmin"),
-             py::arg("xmax"), py::arg("ymin"), py::arg("ymax"))
         .def_readwrite("xmin", &ROI::xmin)
         .def_readwrite("xmax", &ROI::xmax)
         .def_readwrite("ymin", &ROI::ymin)
@@ -217,11 +173,38 @@ void define_file_io_bindings(py::module &m) {
     
 
 
+    py::class_<RawSubFile>(m, "RawSubFile")
+        .def(py::init<const std::filesystem::path &, DetectorType, size_t,
+                      size_t, size_t>())
+        .def_property_readonly("bytes_per_frame", &RawSubFile::bytes_per_frame)
+        .def_property_readonly("pixels_per_frame",
+                               &RawSubFile::pixels_per_frame)
+        .def("seek", &RawSubFile::seek)
+        .def("tell", &RawSubFile::tell)
+        .def_property_readonly("rows", &RawSubFile::rows)
+        .def_property_readonly("cols", &RawSubFile::cols)
+        .def("read_frame",
+             [](RawSubFile &self) {
+                 const uint8_t item_size = self.bytes_per_pixel();
+                 py::array image;
+                 std::vector<ssize_t> shape;
+                 shape.reserve(2);
+                 shape.push_back(self.rows());
+                 shape.push_back(self.cols());
+                 if (item_size == 1) {
+                     image = py::array_t<uint8_t>(shape);
+                 } else if (item_size == 2) {
+                     image = py::array_t<uint16_t>(shape);
+                 } else if (item_size == 4) {
+                     image = py::array_t<uint32_t>(shape);
+                 }
+                 fmt::print("item_size: {} rows: {} cols: {}\n", item_size, self.rows(), self.cols());
+                 self.read_into(
+                     reinterpret_cast<std::byte *>(image.mutable_data()));
+                 return image;
+             });
 
 
-
-
-#pragma GCC diagnostic pop
     // py::class_<ClusterHeader>(m, "ClusterHeader")
     //     .def(py::init<>())
     //     .def_readwrite("frame_number", &ClusterHeader::frame_number)

python/src/fit.hpp

@@ -1,250 +0,0 @@
-#include <cstdint>
-#include <filesystem>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/stl_bind.h>
-
-#include "aare/Fit.hpp"
-
-namespace py = pybind11;
-using namespace pybind11::literals;
-
-
-void define_fit_bindings(py::module &m) {
-
-    // TODO! Evaluate without converting to double
-    m.def(
-        "gaus",
-        [](py::array_t<double, py::array::c_style | py::array::forcecast> x,
-           py::array_t<double, py::array::c_style | py::array::forcecast> par) {
-            auto x_view = make_view_1d(x);
-            auto par_view = make_view_1d(par);
-            auto y = new NDArray<double, 1>{aare::func::gaus(x_view, par_view)};
-            return return_image_data(y);
-        },
-        R"(
-        Evaluate a 1D Gaussian function for all points in x using parameters par.
-
-        Parameters
-        ----------
-        x : array_like
-            The points at which to evaluate the Gaussian function.
-        par : array_like
-            The parameters of the Gaussian function. The first element is the amplitude, the second element is the mean, and the third element is the standard deviation.
-        )",
-        py::arg("x"), py::arg("par"));
-
-    m.def(
-        "pol1",
-        [](py::array_t<double, py::array::c_style | py::array::forcecast> x,
-           py::array_t<double, py::array::c_style | py::array::forcecast> par) {
-            auto x_view = make_view_1d(x);
-            auto par_view = make_view_1d(par);
-            auto y = new NDArray<double, 1>{aare::func::pol1(x_view, par_view)};
-            return return_image_data(y);
-        },
-        R"(
-        Evaluate a 1D polynomial function for all points in x using parameters par. (p0+p1*x)
-        
-        Parameters
-        ----------
-        x : array_like
-            The points at which to evaluate the polynomial function.
-        par : array_like
-            The parameters of the polynomial function. The first element is the intercept, and the second element is the slope.    
-        )",
-        py::arg("x"), py::arg("par"));
-
-
-    m.def(
-        "fit_gaus",
-        [](py::array_t<double, py::array::c_style | py::array::forcecast> x,
-           py::array_t<double, py::array::c_style | py::array::forcecast> y,
-           int n_threads) {
-            if (y.ndim() == 3) {
-                auto par = new NDArray<double, 3>{};
-                auto y_view = make_view_3d(y);
-                auto x_view = make_view_1d(x);
-                *par = aare::fit_gaus(x_view, y_view, n_threads);
-                return return_image_data(par);
-            } else if (y.ndim() == 1) {
-                auto par = new NDArray<double, 1>{};
-                auto y_view = make_view_1d(y);
-                auto x_view = make_view_1d(x);
-                *par = aare::fit_gaus(x_view, y_view);
-                return return_image_data(par);
-            } else {
-                throw std::runtime_error("Data must be 1D or 3D");
-            }
-        },
-        R"(
-
-Fit a 1D Gaussian to data.
-
-Parameters
-----------
-x : array_like
-    The x values.
-y : array_like
-    The y values.
-n_threads : int, optional
-    The number of threads to use. Default is 4.
-)",
-        py::arg("x"), py::arg("y"), py::arg("n_threads") = 4);
-
-    m.def(
-        "fit_gaus",
-        [](py::array_t<double, py::array::c_style | py::array::forcecast> x,
-           py::array_t<double, py::array::c_style | py::array::forcecast> y,
-           py::array_t<double, py::array::c_style | py::array::forcecast> y_err,
-           int n_threads) {
-
-            if (y.ndim() == 3) {
-                // Allocate memory for the output
-                // Need to have pointers to allow python to manage
-                // the memory
-                auto par = new NDArray<double, 3>({y.shape(0), y.shape(1), 3});
-                auto par_err =
-                    new NDArray<double, 3>({y.shape(0), y.shape(1), 3});
-                auto chi2 = new NDArray<double, 2>({y.shape(0), y.shape(1)});
-
-                // Make views of the numpy arrays
-                auto y_view = make_view_3d(y);
-                auto y_view_err = make_view_3d(y_err);
-                auto x_view = make_view_1d(x);
-
-                aare::fit_gaus(x_view, y_view, y_view_err, par->view(),
-                               par_err->view(), chi2->view(), n_threads);
-
-                return py::dict("par"_a = return_image_data(par),
-                                "par_err"_a = return_image_data(par_err),
-                                "chi2"_a = return_image_data(chi2),
-                                "Ndf"_a = y.shape(2) - 3);
-            } else if (y.ndim() == 1) {
-                // Allocate memory for the output
-                // Need to have pointers to allow python to manage
-                // the memory
-                auto par = new NDArray<double, 1>({3});
-                auto par_err = new NDArray<double, 1>({3});
-
-                // Decode the numpy arrays
-                auto y_view = make_view_1d(y);
-                auto y_view_err = make_view_1d(y_err);
-                auto x_view = make_view_1d(x);
-
-
-                double chi2 = 0;
-                aare::fit_gaus(x_view, y_view, y_view_err, par->view(),
-                               par_err->view(), chi2);
-
-                return py::dict("par"_a = return_image_data(par),
-                                "par_err"_a = return_image_data(par_err),
-                                "chi2"_a = chi2, "Ndf"_a = y.size() - 3);
-
-            } else {
-                throw std::runtime_error("Data must be 1D or 3D");
-            }
-        },
-        R"(
-
-Fit a 1D Gaussian to data with error estimates.
-
-Parameters
-----------
-x : array_like
-    The x values.
-y : array_like
-    The y values.
-y_err : array_like
-    The error in the y values.
-n_threads : int, optional
-    The number of threads to use. Default is 4.
-)",
-        py::arg("x"), py::arg("y"), py::arg("y_err"), py::arg("n_threads") = 4);
-
-    m.def(
-        "fit_pol1",
-        [](py::array_t<double, py::array::c_style | py::array::forcecast> x,
-           py::array_t<double, py::array::c_style | py::array::forcecast> y,
-           int n_threads) {
-            if (y.ndim() == 3) {
-                auto par = new NDArray<double, 3>{};
-
-                auto x_view = make_view_1d(x);
-                auto y_view = make_view_3d(y);
-                *par = aare::fit_pol1(x_view, y_view, n_threads);
-                return return_image_data(par);
-            } else if (y.ndim() == 1) {
-                auto par = new NDArray<double, 1>{};
-                auto x_view = make_view_1d(x);
-                auto y_view = make_view_1d(y);
-                *par = aare::fit_pol1(x_view, y_view);
-                return return_image_data(par);
-            } else {
-                throw std::runtime_error("Data must be 1D or 3D");
-            }
-        },
-        py::arg("x"), py::arg("y"), py::arg("n_threads") = 4);
-
-    m.def(
-        "fit_pol1",
-        [](py::array_t<double, py::array::c_style | py::array::forcecast> x,
-           py::array_t<double, py::array::c_style | py::array::forcecast> y,
-           py::array_t<double, py::array::c_style | py::array::forcecast> y_err,
-           int n_threads) {
-            if (y.ndim() == 3) {
-                auto par = new NDArray<double, 3>({y.shape(0), y.shape(1), 2});
-
-                auto par_err =
-                    new NDArray<double, 3>({y.shape(0), y.shape(1), 2});
-
-                auto y_view = make_view_3d(y);
-                auto y_view_err = make_view_3d(y_err);
-                auto x_view = make_view_1d(x);
-
-                auto chi2 = new NDArray<double, 2>({y.shape(0), y.shape(1)});
-
-                aare::fit_pol1(x_view, y_view, y_view_err, par->view(),
-                               par_err->view(), chi2->view(), n_threads);
-                return py::dict("par"_a = return_image_data(par),
-                                "par_err"_a = return_image_data(par_err), 
-                                "chi2"_a = return_image_data(chi2),
-                                "Ndf"_a = y.shape(2) - 2);
-
-
-            } else if (y.ndim() == 1) {
-                auto par = new NDArray<double, 1>({2});
-                auto par_err = new NDArray<double, 1>({2});
-
-                auto y_view = make_view_1d(y);
-                auto y_view_err = make_view_1d(y_err);
-                auto x_view = make_view_1d(x);
-
-                double chi2 = 0;
-
-                aare::fit_pol1(x_view, y_view, y_view_err, par->view(),
-                               par_err->view(), chi2);
-                return py::dict("par"_a = return_image_data(par),
-                                "par_err"_a = return_image_data(par_err),
-                                "chi2"_a = chi2, "Ndf"_a = y.size() - 2);
-
-            } else {
-                throw std::runtime_error("Data must be 1D or 3D");
-            }
-        },
-        R"(
-Fit a 1D polynomial to data with error estimates.
-
-Parameters
-----------
-x : array_like
-    The x values.
-y : array_like
-    The y values.
-y_err : array_like
-    The error in the y values.
-n_threads : int, optional
-    The number of threads to use. Default is 4.
-)",
-        py::arg("x"), py::arg("y"), py::arg("y_err"), py::arg("n_threads") = 4);
-}

python/src/interpolation.hpp

@@ -1,58 +0,0 @@
-#include "aare/Interpolator.hpp"
-#include "aare/NDArray.hpp"
-#include "aare/NDView.hpp"
-#include "np_helper.hpp"
-#include <cstdint>
-#include <filesystem>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-
-namespace py = pybind11;
-void define_interpolation_bindings(py::module &m) {
-
-    PYBIND11_NUMPY_DTYPE(aare::Photon, x,y,energy);
-
-    py::class_<aare::Interpolator>(m, "Interpolator")
-        .def(py::init([](py::array_t<double, py::array::c_style | py::array::forcecast> etacube, py::array_t<double> xbins,
-                         py::array_t<double> ybins, py::array_t<double> ebins) {
-            return Interpolator(make_view_3d(etacube), make_view_1d(xbins),
-                                make_view_1d(ybins), make_view_1d(ebins));
-        }))
-        .def("get_ietax", [](Interpolator& self){
-            auto*ptr = new NDArray<double,3>{};
-            *ptr = self.get_ietax();
-            return return_image_data(ptr);
-        })
-        .def("get_ietay", [](Interpolator& self){
-            auto*ptr = new NDArray<double,3>{};
-            *ptr = self.get_ietay();
-            return return_image_data(ptr);
-        })
-        .def("interpolate", [](Interpolator& self, const ClusterVector<int32_t>& clusters){
-            auto photons = self.interpolate(clusters);
-            auto* ptr = new std::vector<Photon>{photons};
-            return return_vector(ptr);
-        });
-
-    // TODO! Evaluate without converting to double
-    m.def(
-        "hej",
-        []() {
-            // auto boost_histogram = py::module_::import("boost_histogram");
-            // py::object axis =
-            // boost_histogram.attr("axis").attr("Regular")(10, 0.0, 10.0);
-            // py::object histogram = boost_histogram.attr("Histogram")(axis);
-            // return histogram;
-            // return h;
-        },
-        R"(
-        Evaluate a 1D Gaussian function for all points in x using parameters par.
-
-        Parameters
-        ----------
-        x : array_like
-            The points at which to evaluate the Gaussian function.
-        par : array_like
-            The parameters of the Gaussian function. The first element is the amplitude, the second element is the mean, and the third element is the standard deviation.
-        )");
-}

python/src/jungfrau_data_file.hpp

@@ -1,116 +0,0 @@
-
-#include "aare/JungfrauDataFile.hpp"
-#include "aare/defs.hpp"
-
-#include <cstdint>
-#include <filesystem>
-#include <pybind11/iostream.h>
-#include <pybind11/numpy.h>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/stl/filesystem.h>
-#include <string>
-
-namespace py = pybind11;
-using namespace ::aare;
-
-// Disable warnings for unused parameters, as we ignore some
-// in the __exit__ method
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-
-auto read_dat_frame(JungfrauDataFile &self) {
-    py::array_t<JungfrauDataHeader> header(1);
-    py::array_t<uint16_t> image({
-        self.rows(), 
-        self.cols() 
-    });
-
-    self.read_into(reinterpret_cast<std::byte *>(image.mutable_data()),
-                   header.mutable_data());
-
-    return py::make_tuple(header, image);
-}
-
-auto read_n_dat_frames(JungfrauDataFile &self, size_t n_frames) {
-    // adjust for actual frames left in the file
-    n_frames = std::min(n_frames, self.total_frames() - self.tell());
-    if (n_frames == 0) {
-        throw std::runtime_error("No frames left in file");
-    }
-
-    py::array_t<JungfrauDataHeader> header(n_frames);
-    py::array_t<uint16_t> image({
-        n_frames, self.rows(), 
-        self.cols()});
-
-    self.read_into(reinterpret_cast<std::byte *>(image.mutable_data()),
-                   n_frames, header.mutable_data());
-
-    return py::make_tuple(header, image);
-}
-
-void define_jungfrau_data_file_io_bindings(py::module &m) {
-    // Make the JungfrauDataHeader usable from numpy
-    PYBIND11_NUMPY_DTYPE(JungfrauDataHeader, framenum, bunchid);
-
-    py::class_<JungfrauDataFile>(m, "JungfrauDataFile")
-        .def(py::init<const std::filesystem::path &>())
-        .def("seek", &JungfrauDataFile::seek,
-             R"(
-               Seek to the given frame index.
-               )")
-        .def("tell", &JungfrauDataFile::tell,
-             R"(
-               Get the current frame index.
-               )")
-        .def_property_readonly("rows", &JungfrauDataFile::rows)
-        .def_property_readonly("cols", &JungfrauDataFile::cols)
-        .def_property_readonly("base_name", &JungfrauDataFile::base_name)
-        .def_property_readonly("bytes_per_frame",
-                               &JungfrauDataFile::bytes_per_frame)
-        .def_property_readonly("pixels_per_frame",
-                               &JungfrauDataFile::pixels_per_frame)
-        .def_property_readonly("bytes_per_pixel",
-                               &JungfrauDataFile::bytes_per_pixel)
-        .def_property_readonly("bitdepth", &JungfrauDataFile::bitdepth)
-        .def_property_readonly("current_file", &JungfrauDataFile::current_file)
-        .def_property_readonly("total_frames", &JungfrauDataFile::total_frames)
-        .def_property_readonly("n_files", &JungfrauDataFile::n_files)
-        .def("read_frame", &read_dat_frame,
-             R"(
-               Read a single frame from the file.
-               )")
-        .def("read_n", &read_n_dat_frames,
-             R"(
-               Read maximum n_frames frames from the file.
-               )")
-        .def(
-            "read",
-            [](JungfrauDataFile &self) {
-                self.seek(0);
-                auto n_frames = self.total_frames();
-                return read_n_dat_frames(self, n_frames);
-            },
-            R"(
-              Read all frames from the file. Seeks to the beginning before reading.
-              )")
-        .def("__enter__", [](JungfrauDataFile &self) { return &self; })
-        .def("__exit__",
-             [](JungfrauDataFile &self,
-                const std::optional<pybind11::type> &exc_type,
-                const std::optional<pybind11::object> &exc_value,
-                const std::optional<pybind11::object> &traceback) {
-                 //  self.close();
-             })
-        .def("__iter__", [](JungfrauDataFile &self) { return &self; })
-        .def("__next__", [](JungfrauDataFile &self) {
-            try {
-                return read_dat_frame(self);
-            } catch (std::runtime_error &e) {
-                throw py::stop_iteration();
-            }
-        });
-}
-
-#pragma GCC diagnostic pop

python/src/module.cpp

@@ -8,11 +8,6 @@
 #include "pedestal.hpp"
 #include "cluster.hpp"
 #include "cluster_file.hpp"
-#include "fit.hpp"
-#include "interpolation.hpp"
-#include "raw_sub_file.hpp"
-
-#include "jungfrau_data_file.hpp"
 
 //Pybind stuff
 #include <pybind11/pybind11.h>
@@ -23,20 +18,12 @@ namespace py = pybind11;
 PYBIND11_MODULE(_aare, m) {
     define_file_io_bindings(m);
     define_raw_file_io_bindings(m);
-    define_raw_sub_file_io_bindings(m);
     define_ctb_raw_file_io_bindings(m);
     define_raw_master_file_bindings(m);
     define_var_cluster_finder_bindings(m);
     define_pixel_map_bindings(m);
-    define_pedestal_bindings<double>(m, "Pedestal_d");
-    define_pedestal_bindings<float>(m, "Pedestal_f");
+    define_pedestal_bindings<double>(m, "Pedestal");
+    define_pedestal_bindings<float>(m, "Pedestal_float32");
     define_cluster_finder_bindings(m);
-    define_cluster_finder_mt_bindings(m);
     define_cluster_file_io_bindings(m);
-    define_cluster_collector_bindings(m);
-    define_cluster_file_sink_bindings(m);
-    define_fit_bindings(m);
-    define_interpolation_bindings(m);
-    define_jungfrau_data_file_io_bindings(m);
-
 }

python/src/np_helper.hpp

@@ -39,26 +39,78 @@ template <typename T> py::array return_vector(std::vector<T> *vec) {
                           free_when_done); // numpy array references this parent
 }
 
+// template <typename Reader> py::array do_read(Reader &r, size_t n_frames) {
+//     py::array image;
+//     if (n_frames == 0)
+//         n_frames = r.total_frames();
+
+//     std::array<ssize_t, 3> shape{static_cast<ssize_t>(n_frames), r.rows(),
+//                                  r.cols()};
+//     const uint8_t item_size = r.bytes_per_pixel();
+//     if (item_size == 1) {
+//         image = py::array_t<uint8_t, py::array::c_style | py::array::forcecast>(
+//             shape);
+//     } else if (item_size == 2) {
+//         image =
+//             py::array_t<uint16_t, py::array::c_style | py::array::forcecast>(
+//                 shape);
+//     } else if (item_size == 4) {
+//         image =
+//             py::array_t<uint32_t, py::array::c_style | py::array::forcecast>(
+//                 shape);
+//     }
+//     r.read_into(reinterpret_cast<std::byte *>(image.mutable_data()), n_frames);
+//     return image;
+// }
+
+// py::array return_frame(pl::Frame *ptr) {
+//     py::capsule free_when_done(ptr, [](void *f) {
+//         pl::Frame *foo = reinterpret_cast<pl::Frame *>(f);
+//         delete foo;
+//     });
+
+//     const uint8_t item_size = ptr->bytes_per_pixel();
+//     std::vector<ssize_t> shape;
+//     for (auto val : ptr->shape())
+//         if (val > 1)
+//             shape.push_back(val);
+
+//     std::vector<ssize_t> strides;
+//     if (shape.size() == 1)
+//         strides.push_back(item_size);
+//     else if (shape.size() == 2) {
+//         strides.push_back(item_size * shape[1]);
+//         strides.push_back(item_size);
+//     }
+
+//     if (item_size == 1)
+//         return py::array_t<uint8_t>(
+//             shape, strides,
+//             reinterpret_cast<uint8_t *>(ptr->data()), free_when_done);
+//     else if (item_size == 2)
+//         return py::array_t<uint16_t>(shape, strides,
+//                                      reinterpret_cast<uint16_t *>(ptr->data()),
+//                                      free_when_done);
+//     else if (item_size == 4)
+//         return py::array_t<uint32_t>(shape, strides,
+//                                      reinterpret_cast<uint32_t *>(ptr->data()),
+//                                      free_when_done);
+//     return {};
+// }
+
 // todo rewrite generic
-template <class T, int Flags> auto get_shape_3d(const py::array_t<T, Flags>& arr) {
+template <class T, int Flags> auto get_shape_3d(py::array_t<T, Flags> arr) {
     return aare::Shape<3>{arr.shape(0), arr.shape(1), arr.shape(2)};
 }
 
-template <class T, int Flags> auto make_view_3d(py::array_t<T, Flags>& arr) {
+template <class T, int Flags> auto make_view_3d(py::array_t<T, Flags> arr) {
     return aare::NDView<T, 3>(arr.mutable_data(), get_shape_3d<T, Flags>(arr));
 }
 
-template <class T, int Flags> auto get_shape_2d(const py::array_t<T, Flags>& arr) {
+template <class T, int Flags> auto get_shape_2d(py::array_t<T, Flags> arr) {
     return aare::Shape<2>{arr.shape(0), arr.shape(1)};
 }
 
-template <class T, int Flags> auto get_shape_1d(const py::array_t<T, Flags>& arr) {
-    return aare::Shape<1>{arr.shape(0)};
-}
-
-template <class T, int Flags> auto make_view_2d(py::array_t<T, Flags>& arr) {
+template <class T, int Flags> auto make_view_2d(py::array_t<T, Flags> arr) {
     return aare::NDView<T, 2>(arr.mutable_data(), get_shape_2d<T, Flags>(arr));
-}
-template <class T, int Flags> auto make_view_1d(py::array_t<T, Flags>& arr) {
-    return aare::NDView<T, 1>(arr.mutable_data(), get_shape_1d<T, Flags>(arr));
 }

python/src/pedestal.hpp

@@ -43,10 +43,5 @@ template <typename SUM_TYPE> void define_pedestal_bindings(py::module &m, const
         .def("push", [](Pedestal<SUM_TYPE> &pedestal, py::array_t<uint16_t> &f) {
             auto v = make_view_2d(f);
             pedestal.push(v);
-        })
-        .def("push_no_update", [](Pedestal<SUM_TYPE> &pedestal, py::array_t<uint16_t, py::array::c_style> &f) {
-            auto v = make_view_2d(f);
-            pedestal.push_no_update(v);
-        }, py::arg().noconvert())
-        .def("update_mean", &Pedestal<SUM_TYPE>::update_mean);
+        });
 }

python/src/raw_sub_file.hpp

@@ -1,110 +0,0 @@
-#include "aare/CtbRawFile.hpp"
-#include "aare/File.hpp"
-#include "aare/Frame.hpp"
-#include "aare/RawFile.hpp"
-#include "aare/RawMasterFile.hpp"
-#include "aare/RawSubFile.hpp"
-
-#include "aare/defs.hpp"
-// #include "aare/fClusterFileV2.hpp"
-
-#include <cstdint>
-#include <filesystem>
-#include <pybind11/iostream.h>
-#include <pybind11/numpy.h>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/stl/filesystem.h>
-#include <string>
-
-namespace py = pybind11;
-using namespace ::aare;
-
-auto read_frame_from_RawSubFile(RawSubFile &self) {
-    py::array_t<DetectorHeader> header(1);
-    const uint8_t item_size = self.bytes_per_pixel();
-    std::vector<ssize_t> shape{static_cast<ssize_t>(self.rows()),
-        static_cast<ssize_t>(self.cols())};
-    
-    py::array image;
-    if (item_size == 1) {
-        image = py::array_t<uint8_t>(shape);
-    } else if (item_size == 2) {
-        image = py::array_t<uint16_t>(shape);
-    } else if (item_size == 4) {
-        image = py::array_t<uint32_t>(shape);
-    }
-    self.read_into(reinterpret_cast<std::byte *>(image.mutable_data()),
-                   header.mutable_data());
-
-    return py::make_tuple(header, image);
-}
-
-auto read_n_frames_from_RawSubFile(RawSubFile &self, size_t n_frames) {
-    py::array_t<DetectorHeader> header(n_frames);
-    const uint8_t item_size = self.bytes_per_pixel();
-    std::vector<ssize_t> shape{
-        static_cast<ssize_t>(n_frames), 
-        static_cast<ssize_t>(self.rows()),
-        static_cast<ssize_t>(self.cols())
-    };
-    
-    py::array image;
-    if (item_size == 1) {
-        image = py::array_t<uint8_t>(shape);
-    } else if (item_size == 2) {
-        image = py::array_t<uint16_t>(shape);
-    } else if (item_size == 4) {
-        image = py::array_t<uint32_t>(shape);
-    }
-    self.read_into(reinterpret_cast<std::byte *>(image.mutable_data()), n_frames,
-                   header.mutable_data());
-
-    return py::make_tuple(header, image);
-}
-
-
-//Disable warnings for unused parameters, as we ignore some
-//in the __exit__ method
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-
-void define_raw_sub_file_io_bindings(py::module &m) {
-    py::class_<RawSubFile>(m, "RawSubFile")
-        .def(py::init<const std::filesystem::path &, DetectorType, size_t,
-                      size_t, size_t>())
-        .def_property_readonly("bytes_per_frame", &RawSubFile::bytes_per_frame)
-        .def_property_readonly("pixels_per_frame",
-                               &RawSubFile::pixels_per_frame)
-        .def_property_readonly("bytes_per_pixel", &RawSubFile::bytes_per_pixel)                    
-        .def("seek", &RawSubFile::seek)
-        .def("tell", &RawSubFile::tell)
-        .def_property_readonly("rows", &RawSubFile::rows)
-        .def_property_readonly("cols", &RawSubFile::cols)
-        .def_property_readonly("frames_in_file", &RawSubFile::frames_in_file)
-        .def("read_frame", &read_frame_from_RawSubFile)
-        .def("read_n", &read_n_frames_from_RawSubFile)
-        .def("read", [](RawSubFile &self){
-            self.seek(0);
-            auto n_frames = self.frames_in_file();
-            return read_n_frames_from_RawSubFile(self, n_frames);
-        })
-        .def("__enter__", [](RawSubFile &self) { return &self; })
-        .def("__exit__",
-             [](RawSubFile &self,
-                const std::optional<pybind11::type> &exc_type,
-                const std::optional<pybind11::object> &exc_value,
-                const std::optional<pybind11::object> &traceback) {
-             })
-        .def("__iter__", [](RawSubFile &self) { return &self; })
-        .def("__next__", [](RawSubFile &self) {
-            try {
-                return read_frame_from_RawSubFile(self);
-            } catch (std::runtime_error &e) {
-                throw py::stop_iteration();
-            }
-        });
-
-}
-
-#pragma GCC diagnostic pop

python/src/var_cluster.hpp

@@ -19,24 +19,15 @@ using namespace::aare;
 
 void define_var_cluster_finder_bindings(py::module &m) {
     PYBIND11_NUMPY_DTYPE(VarClusterFinder<double>::Hit, size, row, col,
-                         reserved, energy, max, rows, cols, enes);
+                         reserved, energy, max);
 
     py::class_<VarClusterFinder<double>>(m, "VarClusterFinder")
         .def(py::init<Shape<2>, double>())
         .def("labeled",
              [](VarClusterFinder<double> &self) {
-                 auto *ptr = new NDArray<int, 2>(self.labeled());
+                 auto ptr = new NDArray<int, 2>(self.labeled());
                  return return_image_data(ptr);
              })
-        .def("set_noiseMap",
-            [](VarClusterFinder<double> &self,
-                py::array_t<double, py::array::c_style | py::array::forcecast>
-                    noise_map) {
-                auto noise_map_span = make_view_2d(noise_map);
-                self.set_noiseMap(noise_map_span);
-            })
-        .def("set_peripheralThresholdFactor",
-             &VarClusterFinder<double>::set_peripheralThresholdFactor)
         .def("find_clusters",
              [](VarClusterFinder<double> &self,
                 py::array_t<double, py::array::c_style | py::array::forcecast>
@@ -44,30 +35,6 @@ void define_var_cluster_finder_bindings(py::module &m) {
                  auto view = make_view_2d(img);
                  self.find_clusters(view);
              })
-        .def("find_clusters_X",
-             [](VarClusterFinder<double> &self,
-                py::array_t<double, py::array::c_style | py::array::forcecast>
-                    img) {
-                 auto img_span = make_view_2d(img);
-                 self.find_clusters_X(img_span);
-             })
-        .def("single_pass",
-             [](VarClusterFinder<double> &self,
-                py::array_t<double, py::array::c_style | py::array::forcecast>
-                    img) {
-                 auto img_span = make_view_2d(img);
-                 self.single_pass(img_span);
-             })
-        .def("hits",
-             [](VarClusterFinder<double> &self) {
-                 auto ptr = new std::vector<VarClusterFinder<double>::Hit>(
-                     self.steal_hits());
-                 return return_vector(ptr);
-             })
-        .def("clear_hits",
-             [](VarClusterFinder<double> &self) {
-                 self.clear_hits();
-             })
         .def("steal_hits",
              [](VarClusterFinder<double> &self) {
                  auto ptr = new std::vector<VarClusterFinder<double>::Hit>(

python/tests/conftest.py

@@ -1,29 +0,0 @@
-import os
-from pathlib import Path
-import pytest
-
-
-
-def pytest_addoption(parser):
-    parser.addoption(
-        "--files", action="store_true", default=False, help="run slow tests"
-    )
-
-
-def pytest_configure(config):
-    config.addinivalue_line("markers", "files: mark test as needing image files to run")
-
-
-def pytest_collection_modifyitems(config, items):
-    if config.getoption("--files"):
-        return
-    skip = pytest.mark.skip(reason="need --files option to run")
-    for item in items:
-        if "files" in item.keywords:
-            item.add_marker(skip)
-
-
-@pytest.fixture
-def test_data_path():
-    return Path(os.environ["AARE_TEST_DATA"])
-

python/tests/test_RawSubFile.py

@@ -1,36 +0,0 @@
-import pytest
-import numpy as np
-from aare import RawSubFile, DetectorType
-
-
-@pytest.mark.files
-def test_read_a_jungfrau_RawSubFile(test_data_path):
-    with RawSubFile(test_data_path / "raw/jungfrau/jungfrau_single_d0_f1_0.raw", DetectorType.Jungfrau, 512, 1024, 16) as f:
-        assert f.frames_in_file == 3
-
-        headers, frames = f.read()
-
-    assert headers.size == 3
-    assert frames.shape == (3, 512, 1024)
-    
-    # Frame numbers in this file should be 4, 5, 6
-    for i,h in zip(range(4,7,1), headers):
-        assert h["frameNumber"] == i
-
-    # Compare to canned data using numpy
-    data = np.load(test_data_path / "raw/jungfrau/jungfrau_single_0.npy")
-    assert np.all(data[3:6] == frames)
-
-@pytest.mark.files
-def test_iterate_over_a_jungfrau_RawSubFile(test_data_path):
-
-    data = np.load(test_data_path / "raw/jungfrau/jungfrau_single_0.npy")
-
-    with RawSubFile(test_data_path / "raw/jungfrau/jungfrau_single_d0_f0_0.raw", DetectorType.Jungfrau, 512, 1024, 16) as f:
-        i = 0
-        for header, frame in f:
-            assert header["frameNumber"] == i+1
-            assert np.all(frame == data[i])
-            i += 1
-        assert i == 3
-        assert header["frameNumber"] == 3

python/tests/test_jungfrau_dat_files.py

@@ -1,92 +0,0 @@
-import pytest
-import numpy as np
-from aare import JungfrauDataFile
-
-@pytest.mark.files
-def test_jfungfrau_dat_read_number_of_frames(test_data_path):
-    with JungfrauDataFile(test_data_path / "dat/AldoJF500k_000000.dat") as dat_file:
-        assert dat_file.total_frames == 24
-
-    with JungfrauDataFile(test_data_path / "dat/AldoJF250k_000000.dat") as dat_file:
-        assert dat_file.total_frames == 53
-    
-    with JungfrauDataFile(test_data_path / "dat/AldoJF65k_000000.dat") as dat_file:
-        assert dat_file.total_frames == 113
-
-
-@pytest.mark.files
-def test_jfungfrau_dat_read_number_of_file(test_data_path):
-    with JungfrauDataFile(test_data_path / "dat/AldoJF500k_000000.dat") as dat_file:
-        assert dat_file.n_files == 4
-
-    with JungfrauDataFile(test_data_path / "dat/AldoJF250k_000000.dat") as dat_file:
-        assert dat_file.n_files == 7
-    
-    with JungfrauDataFile(test_data_path / "dat/AldoJF65k_000000.dat") as dat_file:
-        assert dat_file.n_files == 7
-
-
-@pytest.mark.files
-def test_read_module(test_data_path):
-    """
-    Read all frames from the series of .dat files. Compare to canned data in npz format. 
-    """
-
-    # Read all frames from the .dat file
-    with JungfrauDataFile(test_data_path / "dat/AldoJF500k_000000.dat") as f:
-        header, data = f.read()
-
-    #Sanity check
-    n_frames = 24
-    assert header.size == n_frames
-    assert data.shape == (n_frames, 512, 1024)
-
-    # Read reference data using numpy
-    with np.load(test_data_path / "dat/AldoJF500k.npz") as f:
-        ref_header = f["headers"]
-        ref_data = f["frames"]
-
-    # Check that the data is the same
-    assert np.all(ref_header == header)
-    assert np.all(ref_data == data)
-
-@pytest.mark.files
-def test_read_half_module(test_data_path):
-
-    # Read all frames from the .dat file
-    with JungfrauDataFile(test_data_path / "dat/AldoJF250k_000000.dat") as f:
-        header, data = f.read()
-
-    n_frames = 53
-    assert header.size == n_frames
-    assert data.shape == (n_frames, 256, 1024)
-
-    # Read reference data using numpy
-    with np.load(test_data_path / "dat/AldoJF250k.npz") as f:
-        ref_header = f["headers"]
-        ref_data = f["frames"]
-
-    # Check that the data is the same
-    assert np.all(ref_header == header)
-    assert np.all(ref_data == data)
-
-
-@pytest.mark.files
-def test_read_single_chip(test_data_path):
-
-    # Read all frames from the .dat file
-    with JungfrauDataFile(test_data_path / "dat/AldoJF65k_000000.dat") as f:
-        header, data = f.read()
-
-    n_frames = 113
-    assert header.size == n_frames
-    assert data.shape == (n_frames, 256, 256)
-
-    # Read reference data using numpy
-    with np.load(test_data_path / "dat/AldoJF65k.npz") as f:
-        ref_header = f["headers"]
-        ref_data = f["frames"]
-
-    # Check that the data is the same
-    assert np.all(ref_header == header)
-    assert np.all(ref_data == data)

src/ClusterFile.cpp

@@ -1,115 +1,34 @@
 #include "aare/ClusterFile.hpp"
 
-#include <algorithm>
-
 namespace aare {
 
-ClusterFile::ClusterFile(const std::filesystem::path &fname, size_t chunk_size,
-                         const std::string &mode)
-    : m_chunk_size(chunk_size), m_mode(mode) {
-
-    if (mode == "r") {
-        fp = fopen(fname.c_str(), "rb");
-        if (!fp) {
-            throw std::runtime_error("Could not open file for reading: " +
-                                     fname.string());
-        }
-    } else if (mode == "w") {
-        fp = fopen(fname.c_str(), "wb");
-        if (!fp) {
-            throw std::runtime_error("Could not open file for writing: " +
-                                     fname.string());
-        }
-    } else if (mode == "a") {
-        fp = fopen(fname.c_str(), "ab");
-        if (!fp) {
-            throw std::runtime_error("Could not open file for appending: " +
-                                     fname.string());
-        }
-    } else {
-        throw std::runtime_error("Unsupported mode: " + mode);
+ClusterFile::ClusterFile(const std::filesystem::path &fname, size_t chunk_size): m_chunk_size(chunk_size) {
+    fp = fopen(fname.c_str(), "rb");
+    if (!fp) {
+        throw std::runtime_error("Could not open file: " + fname.string());
     }
 }
 
-void ClusterFile::set_roi(ROI roi){
-    m_roi = roi;
+ClusterFile::~ClusterFile() {
+    close();
 }
 
-void ClusterFile::set_noise_map(const NDView<int32_t, 2> noise_map){
-    m_noise_map = NDArray<int32_t, 2>(noise_map);
-}
-
-void ClusterFile::set_gain_map(const NDView<double, 2> gain_map){
-    m_gain_map = NDArray<double, 2>(gain_map);
-    
-    // Gain map is passed as ADU/keV to avoid dividing in when applying the gain
-    // map we invert it here
-    for (auto &item : m_gain_map->view()) {
-        item = 1.0 / item;
-    }
-}
-
-ClusterFile::~ClusterFile() { close(); }
-
-void ClusterFile::close() {
-    if (fp) {
+void ClusterFile::close(){
+    if (fp){
         fclose(fp);
         fp = nullptr;
-    }
+    }  
 }
 
-void ClusterFile::write_frame(const ClusterVector<int32_t> &clusters) {
-    if (m_mode != "w" && m_mode != "a") {
-        throw std::runtime_error("File not opened for writing");
-    }
-    if (!(clusters.cluster_size_x() == 3) &&
-        !(clusters.cluster_size_y() == 3)) {
-        throw std::runtime_error("Only 3x3 clusters are supported");
-    }
-    //First write the frame number - 4 bytes
-    int32_t frame_number = clusters.frame_number();
-    if(fwrite(&frame_number, sizeof(frame_number), 1, fp)!=1){
-        throw std::runtime_error(LOCATION + "Could not write frame number");
-    }
-
-    //Then write the number of clusters - 4 bytes
-    uint32_t n_clusters = clusters.size();
-    if(fwrite(&n_clusters, sizeof(n_clusters), 1, fp)!=1){
-        throw std::runtime_error(LOCATION + "Could not write number of clusters");
-    }
-
-    //Now write the clusters in the frame
-    if(fwrite(clusters.data(), clusters.item_size(), clusters.size(), fp)!=clusters.size()){
-        throw std::runtime_error(LOCATION + "Could not write clusters");
-    }
-}
-
-
-ClusterVector<int32_t> ClusterFile::read_clusters(size_t n_clusters){
-    if (m_mode != "r") {
-        throw std::runtime_error("File not opened for reading");
-    }
-    if (m_noise_map || m_roi){
-        return read_clusters_with_cut(n_clusters);
-    }else{
-        return read_clusters_without_cut(n_clusters);
-    }
-}
-
-ClusterVector<int32_t> ClusterFile::read_clusters_without_cut(size_t n_clusters) {
-    if (m_mode != "r") {
-        throw std::runtime_error("File not opened for reading");
-    }
-    
-    ClusterVector<int32_t> clusters(3,3, n_clusters);
+std::vector<Cluster> ClusterFile::read_clusters(size_t n_clusters) {
+    std::vector<Cluster> clusters(n_clusters);
 
     int32_t iframe = 0; // frame number needs to be 4 bytes!
     size_t nph_read = 0;
     uint32_t nn = m_num_left;
     uint32_t nph = m_num_left; // number of clusters in frame needs to be 4
 
-    // auto buf = reinterpret_cast<Cluster3x3 *>(clusters.data());
-    auto buf = clusters.data();
+    auto buf = reinterpret_cast<Cluster *>(clusters.data());
     // if there are photons left from previous frame read them first
     if (nph) {
         if (nph > n_clusters) {
@@ -119,15 +38,13 @@ ClusterVector<int32_t> ClusterFile::read_clusters_without_cut(size_t n_clusters)
         } else {
             nn = nph;
         }
-        nph_read += fread((buf + nph_read*clusters.item_size()),
-                          clusters.item_size(), nn, fp);
+        nph_read += fread(reinterpret_cast<void *>(buf + nph_read), sizeof(Cluster), nn, fp);
         m_num_left = nph - nn; // write back the number of photons left
     }
 
     if (nph_read < n_clusters) {
         // keep on reading frames and photons until reaching n_clusters
         while (fread(&iframe, sizeof(iframe), 1, fp)) {
-            clusters.set_frame_number(iframe);
             // read number of clusters in frame
             if (fread(&nph, sizeof(nph), 1, fp)) {
                 if (nph > (n_clusters - nph_read))
@@ -135,8 +52,8 @@ ClusterVector<int32_t> ClusterFile::read_clusters_without_cut(size_t n_clusters)
                 else
                     nn = nph;
 
-                nph_read += fread((buf + nph_read*clusters.item_size()),
-                                  clusters.item_size(), nn, fp);
+                nph_read +=
+                    fread(reinterpret_cast<void *>(buf + nph_read), sizeof(Cluster), nn, fp);
                 m_num_left = nph - nn;
             }
             if (nph_read >= n_clusters)
@@ -147,256 +64,260 @@ ClusterVector<int32_t> ClusterFile::read_clusters_without_cut(size_t n_clusters)
     // Resize the vector to the number of clusters.
     // No new allocation, only change bounds.
     clusters.resize(nph_read);
-    if(m_gain_map)
-        clusters.apply_gain_map(m_gain_map->view());
     return clusters;
 }
 
-
-ClusterVector<int32_t> ClusterFile::read_clusters_with_cut(size_t n_clusters) {
-    ClusterVector<int32_t> clusters(3,3);
-    clusters.reserve(n_clusters);
-
-    // if there are photons left from previous frame read them first
+std::vector<Cluster> ClusterFile::read_frame(int32_t &out_fnum) {
     if (m_num_left) {
-        while(m_num_left && clusters.size() < n_clusters){
-            Cluster3x3 c = read_one_cluster();
-            if(is_selected(c)){
-                clusters.push_back(c.x, c.y, reinterpret_cast<std::byte*>(c.data));
-            }
-        }
+        throw std::runtime_error("There are still photons left in the last frame");
     }
 
-    // we did not have enough clusters left in the previous frame
-    // keep on reading frames until reaching n_clusters
-    if (clusters.size() < n_clusters) {
-        // sanity check
-        if (m_num_left) {
-            throw std::runtime_error(LOCATION + "Entered second loop with clusters left\n");
-        }
-        
-        int32_t frame_number = 0; // frame number needs to be 4 bytes!
-        while (fread(&frame_number, sizeof(frame_number), 1, fp)) {
-            if (fread(&m_num_left, sizeof(m_num_left), 1, fp)) {
-                clusters.set_frame_number(frame_number); //cluster vector will hold the last frame number
-                while(m_num_left && clusters.size() < n_clusters){
-                    Cluster3x3 c = read_one_cluster();
-                    if(is_selected(c)){
-                        clusters.push_back(c.x, c.y, reinterpret_cast<std::byte*>(c.data));
-                    }
-                }
-            }
-
-            // we have enough clusters, break out of the outer while loop
-            if (clusters.size() >= n_clusters)
-                break;
-        }
-
-    }
-    if(m_gain_map)
-        clusters.apply_gain_map(m_gain_map->view());
-
-    return clusters;
-}
-
-Cluster3x3 ClusterFile::read_one_cluster(){
-    Cluster3x3 c;
-    auto rc = fread(&c, sizeof(c), 1, fp);
-    if (rc != 1) {
-        throw std::runtime_error(LOCATION + "Could not read cluster");
-    }
-    --m_num_left;
-    return c;
-}
-
-ClusterVector<int32_t> ClusterFile::read_frame(){
-    if (m_mode != "r") {
-        throw std::runtime_error(LOCATION + "File not opened for reading");
-    }
-    if (m_noise_map || m_roi){
-        return read_frame_with_cut();
-    }else{
-        return read_frame_without_cut();
-    }
-}
-
-ClusterVector<int32_t> ClusterFile::read_frame_without_cut() {
-    if (m_mode != "r") {
-        throw std::runtime_error("File not opened for reading");
-    }
-    if (m_num_left) {
-        throw std::runtime_error(
-            "There are still photons left in the last frame");
-    }
-    int32_t frame_number;
-    if (fread(&frame_number, sizeof(frame_number), 1, fp) != 1) {
-        throw std::runtime_error(LOCATION + "Could not read frame number");
+    if (fread(&out_fnum, sizeof(out_fnum), 1, fp) != 1) {
+        throw std::runtime_error("Could not read frame number");
     }
 
     int32_t n_clusters; // Saved as 32bit integer in the cluster file
     if (fread(&n_clusters, sizeof(n_clusters), 1, fp) != 1) {
-        throw std::runtime_error(LOCATION + "Could not read number of clusters");
-    }
-
-    ClusterVector<int32_t> clusters(3, 3, n_clusters);
-    clusters.set_frame_number(frame_number);
-
-    if (fread(clusters.data(), clusters.item_size(), n_clusters, fp) !=
-        static_cast<size_t>(n_clusters)) {
-        throw std::runtime_error(LOCATION + "Could not read clusters");
-    }
-    clusters.resize(n_clusters);
-    if (m_gain_map)
-        clusters.apply_gain_map(m_gain_map->view());
-    return clusters;
-}
-
-ClusterVector<int32_t> ClusterFile::read_frame_with_cut() {
-    if (m_mode != "r") {
-        throw std::runtime_error("File not opened for reading");
-    }
-    if (m_num_left) {
-        throw std::runtime_error(
-            "There are still photons left in the last frame");
-    }
-    int32_t frame_number;
-    if (fread(&frame_number, sizeof(frame_number), 1, fp) != 1) {
-        throw std::runtime_error("Could not read frame number");
-    }
-
-
-    if (fread(&m_num_left, sizeof(m_num_left), 1, fp) != 1) {
         throw std::runtime_error("Could not read number of clusters");
     }
-    
-    ClusterVector<int32_t> clusters(3, 3);
-    clusters.reserve(m_num_left);
-    clusters.set_frame_number(frame_number);
-    while(m_num_left){
-        Cluster3x3 c = read_one_cluster();
-        if(is_selected(c)){
-            clusters.push_back(c.x, c.y, reinterpret_cast<std::byte*>(c.data));
-        }
+    std::vector<Cluster> clusters(n_clusters);
+
+    if (fread(clusters.data(), sizeof(Cluster), n_clusters, fp) != static_cast<size_t>(n_clusters)) {
+        throw std::runtime_error("Could not read clusters");
     }
-    if (m_gain_map)
-        clusters.apply_gain_map(m_gain_map->view());
     return clusters;
+
 }
 
+std::vector<Cluster> ClusterFile::read_cluster_with_cut(size_t n_clusters,
+                                                        double *noise_map,
+                                                        int nx, int ny) {
 
+    std::vector<Cluster> clusters(n_clusters);
+    // size_t read_clusters_with_cut(FILE *fp, size_t n_clusters, Cluster *buf,
+    //                               uint32_t *n_left, double *noise_map, int
+    //                               nx, int ny) {
+    int iframe = 0;
+    //     uint32_t nph = *n_left;
+    uint32_t nph = m_num_left;
+    //     uint32_t nn = *n_left;
+    uint32_t nn = m_num_left;
+    size_t nph_read = 0;
 
-bool ClusterFile::is_selected(Cluster3x3 &cl) {
-    //Should fail fast
-    if (m_roi) {
-        if (!(m_roi->contains(cl.x, cl.y))) {
-            return false;
+    int32_t t2max, tot1;
+    int32_t tot3;
+    // Cluster *ptr = buf;
+    Cluster *ptr = clusters.data();
+    int good = 1;
+    double noise;
+    // read photons left from previous frame
+    if (noise_map)
+        printf("Using noise map\n");
+
+    if (nph) {
+        if (nph > n_clusters) {
+            // if we have more photons left in the frame then photons to
+            // read we read directly the requested number
+            nn = n_clusters;
+        } else {
+            nn = nph;
+        }
+        for (size_t iph = 0; iph < nn; iph++) {
+            // read photons 1 by 1
+            size_t n_read = fread(reinterpret_cast<void *>(ptr), sizeof(Cluster), 1, fp);
+            if (n_read != 1) {
+                clusters.resize(nph_read);
+                return clusters;
+            }
+            // TODO! error handling on read
+            good = 1;
+            if (noise_map) {
+                if (ptr->x >= 0 && ptr->x < nx && ptr->y >= 0 && ptr->y < ny) {
+                    tot1 = ptr->data[4];
+                    analyze_cluster(*ptr, &t2max, &tot3, NULL, NULL, NULL, NULL,
+                                    NULL);
+                    noise = noise_map[ptr->y * nx + ptr->x];
+                    if (tot1 > noise || t2max > 2 * noise || tot3 > 3 * noise) {
+                        ;
+                    } else {
+                        good = 0;
+                        printf("%d %d %f %d %d %d\n", ptr->x, ptr->y, noise,
+                               tot1, t2max, tot3);
+                    }
+                } else {
+                    printf("Bad pixel number %d %d\n", ptr->x, ptr->y);
+                    good = 0;
+                }
+            }
+            if (good) {
+                ptr++;
+                nph_read++;
+            }
+            (m_num_left)--;
+            if (nph_read >= n_clusters)
+                break;
         }
     }
-    if (m_noise_map){
-        int32_t sum_1x1 = cl.data[4]; // central pixel
-        int32_t sum_2x2 = cl.sum_2x2(); // highest sum of 2x2 subclusters
-        int32_t sum_3x3 = cl.sum(); // sum of all pixels
+        if (nph_read < n_clusters) {
+    //         // keep on reading frames and photons until reaching n_clusters
+            while (fread(&iframe, sizeof(iframe), 1, fp)) {
+    //             // printf("%d\n",nph_read);
 
-        auto noise = (*m_noise_map)(cl.y, cl.x); //TODO! check if this is correct
-        if (sum_1x1 <= noise || sum_2x2 <= 2 * noise || sum_3x3 <= 3 * noise) {
-            return false;
+                if (fread(&nph, sizeof(nph), 1, fp)) {
+    //                 // printf("** %d\n",nph);
+                    m_num_left = nph;
+                    for (size_t iph = 0; iph < nph; iph++) {
+    //                     // read photons 1 by 1
+                        size_t n_read =
+                            fread(reinterpret_cast<void *>(ptr), sizeof(Cluster), 1, fp);
+                        if (n_read != 1) {
+                            clusters.resize(nph_read);
+                            return clusters;
+                            // return nph_read;
+                        }
+                        good = 1;
+                        if (noise_map) {
+                            if (ptr->x >= 0 && ptr->x < nx && ptr->y >= 0 &&
+                                ptr->y < ny) {
+                                tot1 = ptr->data[4];
+                                analyze_cluster(*ptr, &t2max, &tot3, NULL,
+                                NULL,
+                                                NULL, NULL, NULL);
+                                // noise = noise_map[ptr->y * nx + ptr->x];
+                                noise = noise_map[ptr->y + ny * ptr->x];
+    			    if (tot1 > noise || t2max > 2 * noise ||
+                                    tot3 > 3 * noise) {
+                                    ;
+                                } else
+                                    good = 0;
+                            } else {
+                                printf("Bad pixel number %d %d\n", ptr->x,
+                                ptr->y); good = 0;
+                            }
+                        }
+                        if (good) {
+                            ptr++;
+    			nph_read++;
+                        }
+    		    (m_num_left)--;
+                        if (nph_read >= n_clusters)
+                            break;
+                    }
+                }
+                if (nph_read >= n_clusters)
+                    break;
+            }
+        }
+        // printf("%d\n",nph_read);
+        clusters.resize(nph_read);
+        return clusters;
+
+}
+
+int ClusterFile::analyze_cluster(Cluster cl, int32_t *t2, int32_t *t3, char *quad,
+                    double *eta2x, double *eta2y, double *eta3x,
+                    double *eta3y) {
+
+    return analyze_data(cl.data, t2, t3, quad, eta2x, eta2y, eta3x, eta3y);
+}
+
+int ClusterFile::analyze_data(int32_t *data, int32_t *t2, int32_t *t3, char *quad,
+                 double *eta2x, double *eta2y, double *eta3x, double *eta3y) {
+
+    int ok = 1;
+
+    int32_t tot2[4];
+    int32_t t2max = 0;
+    char c = 0;
+    int32_t val, tot3;
+
+    tot3 = 0;
+    for (int i = 0; i < 4; i++)
+        tot2[i] = 0;
+
+    for (int ix = 0; ix < 3; ix++) {
+        for (int iy = 0; iy < 3; iy++) {
+            val = data[iy * 3 + ix];
+            //	printf ("%d ",data[iy * 3 + ix]);
+            tot3 += val;
+            if (ix <= 1 && iy <= 1)
+                tot2[cBottomLeft] += val;
+            if (ix >= 1 && iy <= 1)
+                tot2[cBottomRight] += val;
+            if (ix <= 1 && iy >= 1)
+                tot2[cTopLeft] += val;
+            if (ix >= 1 && iy >= 1)
+                tot2[cTopRight] += val;
+        }
+        //	printf ("\n");
+    }
+    // printf ("\n");
+
+    if (t2 || quad) {
+
+        t2max = tot2[0];
+        c = cBottomLeft;
+        for (int i = 1; i < 4; i++) {
+            if (tot2[i] > t2max) {
+                t2max = tot2[i];
+                c = i;
+            }
+        }
+	//printf("*** %d %d %d %d -- %d\n",tot2[0],tot2[1],tot2[2],tot2[3],t2max);
+        if (quad)
+            *quad = c;
+        if (t2)
+            *t2 = t2max;
+    }
+    if (t3)
+        *t3 = tot3;
+
+    if (eta2x || eta2y) {
+        if (eta2x)
+            *eta2x = 0;
+        if (eta2y)
+            *eta2y = 0;
+        switch (c) {
+        case cBottomLeft:
+            if (eta2x && (data[3] + data[4]) != 0)
+                *eta2x = static_cast<double>(data[4]) / (data[3] + data[4]);
+            if (eta2y && (data[1] + data[4]) != 0)
+                *eta2y = static_cast<double>(data[4]) / (data[1] + data[4]);
+            break;
+        case cBottomRight:
+            if (eta2x && (data[2] + data[5]) != 0)
+                *eta2x = static_cast<double>(data[5]) / (data[4] + data[5]);
+            if (eta2y && (data[1] + data[4]) != 0)
+                *eta2y = static_cast<double>(data[4]) / (data[1] + data[4]);
+            break;
+        case cTopLeft:
+            if (eta2x && (data[7] + data[4]) != 0)
+                *eta2x = static_cast<double>(data[4]) / (data[3] + data[4]);
+            if (eta2y && (data[7] + data[4]) != 0)
+                *eta2y = static_cast<double>(data[7]) / (data[7] + data[4]);
+            break;
+        case cTopRight:
+            if (eta2x && t2max != 0)
+                *eta2x = static_cast<double>(data[5]) / (data[5] + data[4]);
+            if (eta2y && t2max != 0)
+                *eta2y = static_cast<double>(data[7]) / (data[7] + data[4]);
+            break;
+        default:;
         }
     }
-    //we passed all checks
-    return true;
-}
 
-NDArray<double, 2> calculate_eta2(ClusterVector<int> &clusters) {
-    //TOTO! make work with 2x2 clusters
-    NDArray<double, 2> eta2({static_cast<int64_t>(clusters.size()), 2});
-    
-    if (clusters.cluster_size_x() == 3 || clusters.cluster_size_y() == 3) {
-        for (size_t i = 0; i < clusters.size(); i++) {
-            auto e = calculate_eta2(clusters.at<Cluster3x3>(i));
-            eta2(i, 0) = e.x;
-            eta2(i, 1) = e.y;
-        }
-    }else if(clusters.cluster_size_x() == 2 || clusters.cluster_size_y() == 2){
-        for (size_t i = 0; i < clusters.size(); i++) {
-            auto e = calculate_eta2(clusters.at<Cluster2x2>(i));
-            eta2(i, 0) = e.x;
-            eta2(i, 1) = e.y;
-        }
-    }else{
-        throw std::runtime_error("Only 3x3 and 2x2 clusters are supported");
+    if (eta3x || eta3y) {
+        if (eta3x && (data[3] + data[4] + data[5]) != 0)
+            *eta3x = static_cast<double>(-data[3] + data[3 + 2]) /
+                     (data[3] + data[4] + data[5]);
+        if (eta3y && (data[1] + data[4] + data[7]) != 0)
+            *eta3y = static_cast<double>(-data[1] + data[2 * 3 + 1]) /
+                     (data[1] + data[4] + data[7]);
     }
-    
-    return eta2;
+
+    return ok;
 }
 
-/** 
- * @brief Calculate the eta2 values for a 3x3 cluster and return them in a Eta2 struct
- * containing etay, etax and the corner of the cluster. 
-*/
-Eta2 calculate_eta2(Cluster3x3 &cl) {
-    Eta2 eta{};
-
-    std::array<int32_t, 4> tot2;
-    tot2[0] = cl.data[0] + cl.data[1] + cl.data[3] + cl.data[4];
-    tot2[1] = cl.data[1] + cl.data[2] + cl.data[4] + cl.data[5];
-    tot2[2] = cl.data[3] + cl.data[4] + cl.data[6] + cl.data[7];
-    tot2[3] = cl.data[4] + cl.data[5] + cl.data[7] + cl.data[8];
-
-    auto c = std::max_element(tot2.begin(), tot2.end()) - tot2.begin();
-    eta.sum = tot2[c];
-    switch (c) {
-    case cBottomLeft:
-        if ((cl.data[3] + cl.data[4]) != 0)
-            eta.x =
-                static_cast<double>(cl.data[4]) / (cl.data[3] + cl.data[4]);
-        if ((cl.data[1] + cl.data[4]) != 0)
-            eta.y =
-                static_cast<double>(cl.data[4]) / (cl.data[1] + cl.data[4]);
-        eta.c = cBottomLeft;
-        break;
-    case cBottomRight:
-        if ((cl.data[2] + cl.data[5]) != 0)
-            eta.x =
-                static_cast<double>(cl.data[5]) / (cl.data[4] + cl.data[5]);
-        if ((cl.data[1] + cl.data[4]) != 0)
-            eta.y =
-                static_cast<double>(cl.data[4]) / (cl.data[1] + cl.data[4]);
-        eta.c = cBottomRight;
-        break;
-    case cTopLeft:
-        if ((cl.data[7] + cl.data[4]) != 0)
-            eta.x =
-                static_cast<double>(cl.data[4]) / (cl.data[3] + cl.data[4]);
-        if ((cl.data[7] + cl.data[4]) != 0)
-            eta.y =
-                static_cast<double>(cl.data[7]) / (cl.data[7] + cl.data[4]);
-        eta.c = cTopLeft;
-        break;
-    case cTopRight:
-        if ((cl.data[5] + cl.data[4]) != 0)
-            eta.x =
-                static_cast<double>(cl.data[5]) / (cl.data[5] + cl.data[4]);
-        if ((cl.data[7] + cl.data[4]) != 0)
-            eta.y =
-                static_cast<double>(cl.data[7]) / (cl.data[7] + cl.data[4]);
-        eta.c = cTopRight;
-        break;
-    // no default to allow compiler to warn about missing cases
-    }
-    return eta;
-}
-
-
-Eta2 calculate_eta2(Cluster2x2 &cl) {
-    Eta2 eta{};
-    if ((cl.data[0] + cl.data[1]) != 0)
-        eta.x = static_cast<double>(cl.data[1]) / (cl.data[0] + cl.data[1]);
-    if ((cl.data[0] + cl.data[2]) != 0)
-        eta.y = static_cast<double>(cl.data[2]) / (cl.data[0] + cl.data[2]);
-    eta.sum = cl.data[0] + cl.data[1] + cl.data[2]+ cl.data[3];
-    eta.c = cBottomLeft; //TODO! This is not correct, but need to put something
-    return eta;
-}
 
 
 } // namespace aare

src/ClusterFile.test.cpp

@@ -1,84 +0,0 @@
-#include "aare/ClusterFile.hpp"
-#include "test_config.hpp"
-
-
-#include "aare/defs.hpp"
-#include <catch2/catch_test_macros.hpp>
-#include <filesystem>
-
-
-
-
-using aare::ClusterFile;
-
-
-TEST_CASE("Read one frame from a a cluster file", "[.files]") {
-    //We know that the frame has 97 clusters
-    auto fpath = test_data_path() / "clust" / "single_frame_97_clustrers.clust";
-    REQUIRE(std::filesystem::exists(fpath));
-
-    ClusterFile f(fpath);
-    auto clusters = f.read_frame();
-    REQUIRE(clusters.size() == 97);
-    REQUIRE(clusters.frame_number() == 135);
-}
-
-
-TEST_CASE("Read one frame using ROI", "[.files]") {
-    //We know that the frame has 97 clusters
-    auto fpath = test_data_path() / "clust" / "single_frame_97_clustrers.clust";
-    REQUIRE(std::filesystem::exists(fpath));
-
-    ClusterFile f(fpath);
-    aare::ROI roi;
-    roi.xmin = 0;
-    roi.xmax = 50;
-    roi.ymin = 200;
-    roi.ymax = 249;
-    f.set_roi(roi);
-    auto clusters = f.read_frame();
-    REQUIRE(clusters.size() == 49);
-    REQUIRE(clusters.frame_number() == 135);
-
-    //Check that all clusters are within the ROI
-    for (size_t i = 0; i < clusters.size(); i++) {
-        auto c = clusters.at<aare::Cluster3x3>(i);
-        REQUIRE(c.x >= roi.xmin);
-        REQUIRE(c.x <= roi.xmax);
-        REQUIRE(c.y >= roi.ymin);
-        REQUIRE(c.y <= roi.ymax);
-    }
-
-}
-
-
-
-TEST_CASE("Read clusters from single frame file", "[.files]") {
-
-    auto fpath = test_data_path() / "clust" / "single_frame_97_clustrers.clust";
-
-    REQUIRE(std::filesystem::exists(fpath));
-
-    SECTION("Read fewer clusters than available") {
-        ClusterFile f(fpath);
-        auto clusters = f.read_clusters(50);
-        REQUIRE(clusters.size() == 50);
-         REQUIRE(clusters.frame_number() == 135);
-    }
-    SECTION("Read more clusters than available") {
-        ClusterFile f(fpath);
-        // 100 is the maximum number of clusters read
-        auto clusters = f.read_clusters(100);
-        REQUIRE(clusters.size() == 97);
-        REQUIRE(clusters.frame_number() == 135);
-    }
-    SECTION("Read all clusters") {
-        ClusterFile f(fpath);
-        auto clusters = f.read_clusters(97);
-        REQUIRE(clusters.size() == 97);
-        REQUIRE(clusters.frame_number() == 135);
-    }
-
-
-    
-}

src/ClusterVector.test.cpp

@@ -1,198 +0,0 @@
-#include <cstdint>
-#include "aare/ClusterVector.hpp"
-
-#include <catch2/matchers/catch_matchers_floating_point.hpp>
-#include <catch2/catch_test_macros.hpp>
-
-using aare::ClusterVector;
-
-struct Cluster_i2x2 {
-    int16_t x;
-    int16_t y;
-    int32_t data[4];
-};
-
-TEST_CASE("ClusterVector 2x2 int32_t capacity 4, push back then read") {
-    
-
-    ClusterVector<int32_t> cv(2, 2, 4);
-    REQUIRE(cv.capacity() == 4);
-    REQUIRE(cv.size() == 0);
-    REQUIRE(cv.cluster_size_x() == 2);
-    REQUIRE(cv.cluster_size_y() == 2);
-    // int16_t, int16_t, 2x2 int32_t = 20 bytes
-    REQUIRE(cv.item_size() == 20);
-
-    //Create a cluster and push back into the vector
-    Cluster_i2x2 c1 = {1, 2, {3, 4, 5, 6}};
-    cv.push_back(c1.x, c1.y, reinterpret_cast<std::byte*>(&c1.data[0]));
-    REQUIRE(cv.size() == 1);
-    REQUIRE(cv.capacity() == 4);
-
-    //Read the cluster back out using copy. TODO! Can we improve the API?
-    Cluster_i2x2 c2;
-    std::byte *ptr = cv.element_ptr(0);
-    std::copy(ptr, ptr + cv.item_size(), reinterpret_cast<std::byte*>(&c2));
-
-    //Check that the data is the same
-    REQUIRE(c1.x == c2.x);
-    REQUIRE(c1.y == c2.y);
-    for(size_t i = 0; i < 4; i++) {
-        REQUIRE(c1.data[i] == c2.data[i]);
-    }
-}
-
-TEST_CASE("Summing 3x1 clusters of int64"){
-    struct Cluster_l3x1{
-        int16_t x;
-        int16_t y;
-        int32_t data[3];
-    };
-
-    ClusterVector<int32_t> cv(3, 1, 2);
-    REQUIRE(cv.capacity() == 2);
-    REQUIRE(cv.size() == 0);
-    REQUIRE(cv.cluster_size_x() == 3);
-    REQUIRE(cv.cluster_size_y() == 1);
-
-    //Create a cluster and push back into the vector
-    Cluster_l3x1 c1 = {1, 2, {3, 4, 5}};
-    cv.push_back(c1.x, c1.y, reinterpret_cast<std::byte*>(&c1.data[0]));
-    REQUIRE(cv.capacity() == 2);
-    REQUIRE(cv.size() == 1);
-
-    Cluster_l3x1 c2 = {6, 7, {8, 9, 10}};
-    cv.push_back(c2.x, c2.y, reinterpret_cast<std::byte*>(&c2.data[0]));
-    REQUIRE(cv.capacity() == 2);
-    REQUIRE(cv.size() == 2);
-
-    Cluster_l3x1 c3 = {11, 12, {13, 14, 15}};
-    cv.push_back(c3.x, c3.y, reinterpret_cast<std::byte*>(&c3.data[0]));
-    REQUIRE(cv.capacity() == 4);
-    REQUIRE(cv.size() == 3);
-
-    auto sums = cv.sum();
-    REQUIRE(sums.size() == 3);
-    REQUIRE(sums[0] == 12);
-    REQUIRE(sums[1] == 27);
-    REQUIRE(sums[2] == 42);
-}
-
-TEST_CASE("Storing floats"){
-    struct Cluster_f4x2{
-        int16_t x;
-        int16_t y;
-        float data[8];
-    };
-
-    ClusterVector<float> cv(2, 4, 10);
-    REQUIRE(cv.capacity() == 10);
-    REQUIRE(cv.size() == 0);
-    REQUIRE(cv.cluster_size_x() == 2);
-    REQUIRE(cv.cluster_size_y() == 4);
-
-    //Create a cluster and push back into the vector
-    Cluster_f4x2 c1 = {1, 2, {3.0, 4.0, 5.0, 6.0,3.0, 4.0, 5.0, 6.0}};
-    cv.push_back(c1.x, c1.y, reinterpret_cast<std::byte*>(&c1.data[0]));
-    REQUIRE(cv.capacity() == 10);
-    REQUIRE(cv.size() == 1);
-    
-
-    Cluster_f4x2 c2 = {6, 7, {8.0, 9.0, 10.0, 11.0,8.0, 9.0, 10.0, 11.0}};
-    cv.push_back(c2.x, c2.y, reinterpret_cast<std::byte*>(&c2.data[0]));
-    REQUIRE(cv.capacity() == 10);
-    REQUIRE(cv.size() == 2);
-
-    auto sums = cv.sum();
-    REQUIRE(sums.size() == 2);
-    REQUIRE_THAT(sums[0], Catch::Matchers::WithinAbs(36.0, 1e-6));
-    REQUIRE_THAT(sums[1], Catch::Matchers::WithinAbs(76.0, 1e-6));
-}
-
-TEST_CASE("Push back more than initial capacity"){
-    
-    ClusterVector<int32_t> cv(2, 2, 2);
-    auto initial_data = cv.data();
-    Cluster_i2x2 c1 = {1, 2, {3, 4, 5, 6}};
-    cv.push_back(c1.x, c1.y, reinterpret_cast<std::byte*>(&c1.data[0]));
-    REQUIRE(cv.size() == 1);
-    REQUIRE(cv.capacity() == 2);
-
-    Cluster_i2x2 c2 = {6, 7, {8, 9, 10, 11}};
-    cv.push_back(c2.x, c2.y, reinterpret_cast<std::byte*>(&c2.data[0]));
-    REQUIRE(cv.size() == 2);
-    REQUIRE(cv.capacity() == 2);
-
-    Cluster_i2x2 c3 = {11, 12, {13, 14, 15, 16}};
-    cv.push_back(c3.x, c3.y, reinterpret_cast<std::byte*>(&c3.data[0]));
-    REQUIRE(cv.size() == 3); 
-    REQUIRE(cv.capacity() == 4);
-
-    Cluster_i2x2* ptr = reinterpret_cast<Cluster_i2x2*>(cv.data());
-    REQUIRE(ptr[0].x == 1);
-    REQUIRE(ptr[0].y == 2);
-    REQUIRE(ptr[1].x == 6);
-    REQUIRE(ptr[1].y == 7);
-    REQUIRE(ptr[2].x == 11);
-    REQUIRE(ptr[2].y == 12);
-
-    //We should have allocated a new buffer, since we outgrew the initial capacity
-    REQUIRE(initial_data != cv.data());
-
-}
-
-TEST_CASE("Concatenate two cluster vectors where the first has enough capacity"){
-    ClusterVector<int32_t> cv1(2, 2, 12);
-    Cluster_i2x2 c1 = {1, 2, {3, 4, 5, 6}};
-    cv1.push_back(c1.x, c1.y, reinterpret_cast<std::byte*>(&c1.data[0]));
-    Cluster_i2x2 c2 = {6, 7, {8, 9, 10, 11}};
-    cv1.push_back(c2.x, c2.y, reinterpret_cast<std::byte*>(&c2.data[0]));
-
-    ClusterVector<int32_t> cv2(2, 2, 2);
-    Cluster_i2x2 c3 = {11, 12, {13, 14, 15, 16}};
-    cv2.push_back(c3.x, c3.y, reinterpret_cast<std::byte*>(&c3.data[0]));
-    Cluster_i2x2 c4 = {16, 17, {18, 19, 20, 21}};
-    cv2.push_back(c4.x, c4.y, reinterpret_cast<std::byte*>(&c4.data[0]));
-
-    cv1 += cv2;
-    REQUIRE(cv1.size() == 4);
-    REQUIRE(cv1.capacity() == 12);
-
-    Cluster_i2x2* ptr = reinterpret_cast<Cluster_i2x2*>(cv1.data());
-    REQUIRE(ptr[0].x == 1);
-    REQUIRE(ptr[0].y == 2);
-    REQUIRE(ptr[1].x == 6);
-    REQUIRE(ptr[1].y == 7);
-    REQUIRE(ptr[2].x == 11);
-    REQUIRE(ptr[2].y == 12);
-    REQUIRE(ptr[3].x == 16);
-    REQUIRE(ptr[3].y == 17);
-}
-
-TEST_CASE("Concatenate two cluster vectors where we need to allocate"){
-    ClusterVector<int32_t> cv1(2, 2, 2);
-    Cluster_i2x2 c1 = {1, 2, {3, 4, 5, 6}};
-    cv1.push_back(c1.x, c1.y, reinterpret_cast<std::byte*>(&c1.data[0]));
-    Cluster_i2x2 c2 = {6, 7, {8, 9, 10, 11}};
-    cv1.push_back(c2.x, c2.y, reinterpret_cast<std::byte*>(&c2.data[0]));
-
-    ClusterVector<int32_t> cv2(2, 2, 2);
-    Cluster_i2x2 c3 = {11, 12, {13, 14, 15, 16}};
-    cv2.push_back(c3.x, c3.y, reinterpret_cast<std::byte*>(&c3.data[0]));
-    Cluster_i2x2 c4 = {16, 17, {18, 19, 20, 21}};
-    cv2.push_back(c4.x, c4.y, reinterpret_cast<std::byte*>(&c4.data[0]));
-
-    cv1 += cv2;
-    REQUIRE(cv1.size() == 4);
-    REQUIRE(cv1.capacity() == 4);
-
-    Cluster_i2x2* ptr = reinterpret_cast<Cluster_i2x2*>(cv1.data());
-    REQUIRE(ptr[0].x == 1);
-    REQUIRE(ptr[0].y == 2);
-    REQUIRE(ptr[1].x == 6);
-    REQUIRE(ptr[1].y == 7);
-    REQUIRE(ptr[2].x == 11);
-    REQUIRE(ptr[2].y == 12);
-    REQUIRE(ptr[3].x == 16);
-    REQUIRE(ptr[3].y == 17);
-}

src/Dtype.cpp

@@ -70,7 +70,7 @@ uint8_t Dtype::bitdepth() const {
 /**
  * @brief Get the number of bytes of the data type
  */
-size_t Dtype::bytes() const { return bitdepth() / bits_per_byte; }
+size_t Dtype::bytes() const { return bitdepth() / 8; }
 
 /**
  * @brief Construct a DType object from a TypeIndex

src/File.cpp

@@ -1,5 +1,4 @@
 #include "aare/File.hpp"
-#include "aare/JungfrauDataFile.hpp"
 #include "aare/NumpyFile.hpp"
 #include "aare/RawFile.hpp"
 
@@ -28,8 +27,6 @@ File::File(const std::filesystem::path &fname, const std::string &mode,
     else if (fname.extension() == ".npy") {
         // file_impl = new NumpyFile(fname, mode, cfg);
         file_impl = std::make_unique<NumpyFile>(fname, mode, cfg);
-    }else if(fname.extension() == ".dat"){
-        file_impl = std::make_unique<JungfrauDataFile>(fname);
     } else {
         throw std::runtime_error("Unsupported file type");
     }
@@ -48,8 +45,6 @@ File& File::operator=(File &&other) noexcept {
     return *this;
 }
 
-// void File::close() { file_impl->close(); }
-
 Frame File::read_frame() { return file_impl->read_frame(); }
 Frame File::read_frame(size_t frame_index) {
     return file_impl->read_frame(frame_index);
@@ -63,8 +58,6 @@ void File::read_into(std::byte *image_buf) { file_impl->read_into(image_buf); }
 void File::read_into(std::byte *image_buf, size_t n_frames) {
     file_impl->read_into(image_buf, n_frames);
 }
-
-size_t File::frame_number() { return file_impl->frame_number(tell()); }
 size_t File::frame_number(size_t frame_index) {
     return file_impl->frame_number(frame_index);
 }
@@ -76,7 +69,7 @@ size_t File::tell() const { return file_impl->tell(); }
 size_t File::rows() const { return file_impl->rows(); }
 size_t File::cols() const { return file_impl->cols(); }
 size_t File::bitdepth() const { return file_impl->bitdepth(); }
-size_t File::bytes_per_pixel() const { return file_impl->bitdepth() / bits_per_byte; }
+size_t File::bytes_per_pixel() const { return file_impl->bitdepth() / 8; }
 
 DetectorType File::detector_type() const { return file_impl->detector_type(); }
 

src/FilePtr.cpp

@@ -1,44 +0,0 @@
-
-#include "aare/FilePtr.hpp"
-#include <fmt/format.h>
-#include <stdexcept>
-#include <utility>
-
-namespace aare {
-
-FilePtr::FilePtr(const std::filesystem::path& fname, const std::string& mode = "rb") {
-    fp_ = fopen(fname.c_str(), mode.c_str());
-    if (!fp_)
-        throw std::runtime_error(fmt::format("Could not open: {}", fname.c_str()));
-}
-
-FilePtr::FilePtr(FilePtr &&other) { std::swap(fp_, other.fp_); }
-
-FilePtr &FilePtr::operator=(FilePtr &&other) {
-    std::swap(fp_, other.fp_);
-    return *this;
-}
-
-FILE *FilePtr::get() { return fp_; }
-
-int64_t FilePtr::tell() {
-    auto pos = ftell(fp_);
-    if (pos == -1)
-        throw std::runtime_error(fmt::format("Error getting file position: {}", error_msg()));
-    return pos;
-} 
-FilePtr::~FilePtr() {
-    if (fp_)
-        fclose(fp_); // check?
-}
-
-std::string FilePtr::error_msg(){
-    if (feof(fp_)) {
-        return "End of file reached";
-    }
-    if (ferror(fp_)) {
-        return fmt::format("Error reading file: {}", std::strerror(errno));
-    }
-    return "";
-}
-} // namespace aare

src/Fit.cpp

@@ -1,276 +0,0 @@
-#include "aare/Fit.hpp"
-#include "aare/utils/task.hpp"
-#include "aare/utils/par.hpp"
-#include <lmcurve2.h>
-#include <lmfit.hpp>
-#include <thread>
-
-#include <array>
-
-
-namespace aare {
-
-namespace func {
-
-double gaus(const double x, const double *par) {
-    return par[0] * exp(-pow(x - par[1], 2) / (2 * pow(par[2], 2)));
-}
-
-NDArray<double, 1> gaus(NDView<double, 1> x, NDView<double, 1> par) {
-    NDArray<double, 1> y({x.shape(0)}, 0);
-    for (ssize_t i = 0; i < x.size(); i++) {
-        y(i) = gaus(x(i), par.data());
-    }
-    return y;
-}
-
-double pol1(const double x, const double *par) { return par[0] * x + par[1]; }
-
-NDArray<double, 1> pol1(NDView<double, 1> x, NDView<double, 1> par) {
-    NDArray<double, 1> y({x.shape()}, 0);
-    for (ssize_t i = 0; i < x.size(); i++) {
-        y(i) = pol1(x(i), par.data());
-    }
-    return y;
-}
-
-} // namespace func
-
-NDArray<double, 1> fit_gaus(NDView<double, 1> x, NDView<double, 1> y) {
-    NDArray<double, 1> result = gaus_init_par(x, y);
-    lm_status_struct status;
-
-    lmcurve(result.size(), result.data(), x.size(), x.data(), y.data(),
-            aare::func::gaus, &lm_control_double, &status);
-
-    return result;
-}
-
-NDArray<double, 3> fit_gaus(NDView<double, 1> x, NDView<double, 3> y,
-                            int n_threads) {
-    NDArray<double, 3> result({y.shape(0), y.shape(1), 3}, 0);
-
-    auto process = [&x, &y, &result](ssize_t first_row, ssize_t last_row) {
-        for (ssize_t row = first_row; row < last_row; row++) {
-            for (ssize_t col = 0; col < y.shape(1); col++) {
-                NDView<double, 1> values(&y(row, col, 0), {y.shape(2)});
-                auto res = fit_gaus(x, values);
-                result(row, col, 0) = res(0);
-                result(row, col, 1) = res(1);
-                result(row, col, 2) = res(2);
-            }
-        }
-    };
-
-    auto tasks = split_task(0, y.shape(0), n_threads);
-    RunInParallel(process, tasks);
-    return result;
-}
-
-std::array<double, 3> gaus_init_par(const NDView<double, 1> x, const NDView<double, 1> y) {
-    std::array<double, 3> start_par{0, 0, 0};
-    auto e = std::max_element(y.begin(), y.end());
-    auto idx = std::distance(y.begin(), e);
-
-    start_par[0] = *e; // For amplitude we use the maximum value
-    start_par[1] =
-        x[idx]; // For the mean we use the x value of the maximum value
-
-    // For sigma we estimate the fwhm and divide by 2.35
-    // assuming equally spaced x values
-    auto delta = x[1] - x[0];
-    start_par[2] =
-        std::count_if(y.begin(), y.end(),
-                      [e, delta](double val) { return val > *e / 2; }) *
-        delta / 2.35;
-
-    return start_par;
-}
-
-
-std::array<double, 2> pol1_init_par(const NDView<double, 1> x, const NDView<double, 1> y){
-        // Estimate the initial parameters for the fit
-        std::array<double, 2> start_par{0, 0};
-
-    
-        auto y2 = std::max_element(y.begin(), y.end());
-        auto x2 = x[std::distance(y.begin(), y2)];
-        auto y1 = std::min_element(y.begin(), y.end());
-        auto x1 = x[std::distance(y.begin(), y1)];
-    
-        start_par[0] =
-            (*y2 - *y1) / (x2 - x1); // For amplitude we use the maximum value
-        start_par[1] =
-            *y1 - ((*y2 - *y1) / (x2 - x1)) *
-                      x1; // For the mean we use the x value of the maximum value
-        return start_par;
-}
-
-void fit_gaus(NDView<double, 1> x, NDView<double, 1> y, NDView<double, 1> y_err,
-              NDView<double, 1> par_out, NDView<double, 1> par_err_out,
-              double &chi2) {
-
-    // Check that we have the correct sizes
-    if (y.size() != x.size() || y.size() != y_err.size() ||
-        par_out.size() != 3 || par_err_out.size() != 3) {
-        throw std::runtime_error("Data, x, data_err must have the same size "
-                                 "and par_out, par_err_out must have size 3");
-    }
-
-
-    // /* Collection of output parameters for status info. */
-    // typedef struct {
-    //     double fnorm;  /* norm of the residue vector fvec. */
-    //     int nfev;      /* actual number of iterations. */
-    //     int outcome;   /* Status indicator. Nonnegative values are used as
-    //     index
-    //                     for the message text lm_infmsg, set in lmmin.c. */
-    //     int userbreak; /* Set when function evaluation requests termination.
-    //     */
-    // } lm_status_struct;
-
-
-    lm_status_struct status;
-    par_out = gaus_init_par(x, y);
-    std::array<double, 9> cov{0, 0, 0, 0, 0, 0, 0 , 0 , 0};
-
-    // void lmcurve2( const int n_par, double *par, double *parerr, double *covar, const int m_dat, const double *t, const double *y, const double *dy, double (*f)( const double ti, const double *par ), const lm_control_struct *control, lm_status_struct *status);
-    // n_par - Number of free variables. Length of parameter vector par.
-    // par - Parameter vector. On input, it must contain a reasonable guess. On output, it contains the solution found to minimize ||r||.
-    // parerr - Parameter uncertainties vector. Array of length n_par or NULL. On output, unless it or covar is NULL, it contains the weighted parameter uncertainties for the found parameters.
-    // covar - Covariance matrix. Array of length n_par * n_par or NULL. On output, unless it is NULL, it contains the covariance matrix.
-    // m_dat - Number of data points. Length of vectors t, y, dy. Must statisfy n_par <= m_dat.
-    // t - Array of length m_dat. Contains the abcissae (time, or "x") for which function f will be evaluated.
-    // y - Array of length m_dat. Contains the ordinate values that shall be fitted.
-    // dy - Array of length m_dat. Contains the standard deviations of the values y.
-    // f - A user-supplied parametric function f(ti;par).
-    // control - Parameter collection for tuning the fit procedure. In most cases, the default &lm_control_double is adequate. If f is only computed with single-precision accuracy, &lm_control_float should be used. Parameters are explained in lmmin2(3).
-    // status - A record used to return information about the minimization process: For details, see lmmin2(3).
-
-    lmcurve2(par_out.size(), par_out.data(), par_err_out.data(), cov.data(),
-             x.size(), x.data(), y.data(), y_err.data(), aare::func::gaus,
-             &lm_control_double, &status);
-
-    // Calculate chi2
-    chi2 = 0;
-    for (ssize_t i = 0; i < y.size(); i++) {
-        chi2 += std::pow((y(i) - func::gaus(x(i), par_out.data())) / y_err(i), 2);
-    }
-}
-
-void fit_gaus(NDView<double, 1> x, NDView<double, 3> y, NDView<double, 3> y_err,
-              NDView<double, 3> par_out, NDView<double, 3> par_err_out,  NDView<double, 2> chi2_out,
-
-              int n_threads) {
-
-    auto process = [&](ssize_t first_row, ssize_t last_row) {
-        for (ssize_t row = first_row; row < last_row; row++) {
-            for (ssize_t col = 0; col < y.shape(1); col++) {
-                NDView<double, 1> y_view(&y(row, col, 0), {y.shape(2)});
-                NDView<double, 1> y_err_view(&y_err(row, col, 0),
-                                             {y_err.shape(2)});
-                NDView<double, 1> par_out_view(&par_out(row, col, 0),
-                                               {par_out.shape(2)});
-                NDView<double, 1> par_err_out_view(&par_err_out(row, col, 0),
-                                                   {par_err_out.shape(2)});
- 
-                fit_gaus(x, y_view, y_err_view, par_out_view, par_err_out_view,
-                         chi2_out(row, col));
-
-            }
-        }
-    };
-
-    auto tasks = split_task(0, y.shape(0), n_threads);
-    RunInParallel(process, tasks);
-}
-
-void fit_pol1(NDView<double, 1> x, NDView<double, 1> y, NDView<double, 1> y_err,
-              NDView<double, 1> par_out, NDView<double, 1> par_err_out, double& chi2) {
-
-    // Check that we have the correct sizes
-    if (y.size() != x.size() || y.size() != y_err.size() ||
-        par_out.size() != 2 || par_err_out.size() != 2) {
-        throw std::runtime_error("Data, x, data_err must have the same size "
-                                 "and par_out, par_err_out must have size 2");
-    }
-
-    lm_status_struct status;
-    par_out = pol1_init_par(x, y);
-    std::array<double, 4> cov{0, 0, 0, 0};
-
-    lmcurve2(par_out.size(), par_out.data(), par_err_out.data(), cov.data(),
-             x.size(), x.data(), y.data(), y_err.data(), aare::func::pol1,
-             &lm_control_double, &status);
-
-    // Calculate chi2
-    chi2 = 0;
-    for (ssize_t i = 0; i < y.size(); i++) {
-        chi2 += std::pow((y(i) - func::pol1(x(i), par_out.data())) / y_err(i), 2);
-    }
-}
-
-void fit_pol1(NDView<double, 1> x, NDView<double, 3> y, NDView<double, 3> y_err,
-              NDView<double, 3> par_out, NDView<double, 3> par_err_out, NDView<double, 2> chi2_out,
-              int n_threads) {
-
-    auto process = [&](ssize_t first_row, ssize_t last_row) {
-        for (ssize_t row = first_row; row < last_row; row++) {
-            for (ssize_t col = 0; col < y.shape(1); col++) {
-                NDView<double, 1> y_view(&y(row, col, 0), {y.shape(2)});
-                NDView<double, 1> y_err_view(&y_err(row, col, 0),
-                                             {y_err.shape(2)});
-                NDView<double, 1> par_out_view(&par_out(row, col, 0),
-                                               {par_out.shape(2)});
-                NDView<double, 1> par_err_out_view(&par_err_out(row, col, 0),
-                                                   {par_err_out.shape(2)});
-
-                fit_pol1(x, y_view, y_err_view, par_out_view, par_err_out_view, chi2_out(row, col));
-
-            }
-        }
-    };
-
-    auto tasks = split_task(0, y.shape(0), n_threads);
-    RunInParallel(process, tasks);
-
-}
-
-NDArray<double, 1> fit_pol1(NDView<double, 1> x, NDView<double, 1> y) {
-    // // Check that we have the correct sizes
-    // if (y.size() != x.size() || y.size() != y_err.size() ||
-    // par_out.size() != 2 || par_err_out.size() != 2) {
-    // throw std::runtime_error("Data, x, data_err must have the same size "
-    //                      "and par_out, par_err_out must have size 2");
-    // }
-    NDArray<double, 1> par = pol1_init_par(x, y);
-
-    lm_status_struct status;
-    lmcurve(par.size(), par.data(), x.size(), x.data(), y.data(),
-            aare::func::pol1, &lm_control_double, &status);
-
-    return par;
-}
-
-NDArray<double, 3> fit_pol1(NDView<double, 1> x, NDView<double, 3> y,
-                            int n_threads) {
-    NDArray<double, 3> result({y.shape(0), y.shape(1), 2}, 0);
-
-    auto process = [&](ssize_t first_row, ssize_t last_row) {
-        for (ssize_t row = first_row; row < last_row; row++) {
-            for (ssize_t col = 0; col < y.shape(1); col++) {
-                NDView<double, 1> values(&y(row, col, 0), {y.shape(2)});
-                auto res = fit_pol1(x, values);
-                result(row, col, 0) = res(0);
-                result(row, col, 1) = res(1);
-            }
-        }
-    };
-
-    auto tasks = split_task(0, y.shape(0), n_threads);
-
-    RunInParallel(process, tasks);
-    return result;
-}
-
-} // namespace aare

src/Frame.test.cpp

@@ -19,7 +19,7 @@ TEST_CASE("Construct a frame") {
     // data should be initialized to 0
     for (size_t i = 0; i < rows; i++) {
         for (size_t j = 0; j < cols; j++) {
-            uint8_t *data = reinterpret_cast<uint8_t *>(frame.pixel_ptr(i, j));
+            uint8_t *data = (uint8_t *)frame.pixel_ptr(i, j);
             REQUIRE(data != nullptr);
             REQUIRE(*data == 0);
         }
@@ -40,7 +40,7 @@ TEST_CASE("Set a value in a 8 bit frame") {
     // only the value we did set should be non-zero
     for (size_t i = 0; i < rows; i++) {
         for (size_t j = 0; j < cols; j++) {
-            uint8_t *data = reinterpret_cast<uint8_t *>(frame.pixel_ptr(i, j));
+            uint8_t *data = (uint8_t *)frame.pixel_ptr(i, j);
             REQUIRE(data != nullptr);
             if (i == 5 && j == 7) {
                 REQUIRE(*data == value);
@@ -65,7 +65,7 @@ TEST_CASE("Set a value in a 64 bit frame") {
     // only the value we did set should be non-zero
     for (size_t i = 0; i < rows; i++) {
         for (size_t j = 0; j < cols; j++) {
-            uint64_t *data = reinterpret_cast<uint64_t *>(frame.pixel_ptr(i, j));
+            uint64_t *data = (uint64_t *)frame.pixel_ptr(i, j);
             REQUIRE(data != nullptr);
             if (i == 5 && j == 7) {
                 REQUIRE(*data == value);
@@ -149,5 +149,4 @@ TEST_CASE("test explicit copy constructor") {
     REQUIRE(frame2.bitdepth() == bitdepth);
     REQUIRE(frame2.bytes() == rows * cols * bitdepth / 8);
     REQUIRE(frame2.data() != data);
-}
-
+}

src/Interpolator.cpp

@@ -1,139 +0,0 @@
-#include "aare/Interpolator.hpp"
-#include "aare/algorithm.hpp"
-
-namespace aare {
-
-Interpolator::Interpolator(NDView<double, 3> etacube, NDView<double, 1> xbins,
-                           NDView<double, 1> ybins, NDView<double, 1> ebins)
-    : m_ietax(etacube), m_ietay(etacube), m_etabinsx(xbins), m_etabinsy(ybins), m_energy_bins(ebins) {
-    if (etacube.shape(0) != xbins.size() || etacube.shape(1) != ybins.size() ||
-        etacube.shape(2) != ebins.size()) {
-        throw std::invalid_argument(
-            "The shape of the etacube does not match the shape of the bins");
-    }
-
-    // Cumulative sum in the x direction
-    for (ssize_t i = 1; i < m_ietax.shape(0); i++) {
-        for (ssize_t j = 0; j < m_ietax.shape(1); j++) {
-            for (ssize_t k = 0; k < m_ietax.shape(2); k++) {
-                m_ietax(i, j, k) += m_ietax(i - 1, j, k);
-            }
-        }
-    }
-
-    // Normalize by the highest row, if norm less than 1 don't do anything
-    for (ssize_t i = 0; i < m_ietax.shape(0); i++) {
-        for (ssize_t j = 0; j < m_ietax.shape(1); j++) {
-            for (ssize_t k = 0; k < m_ietax.shape(2); k++) {
-                auto val = m_ietax(m_ietax.shape(0) - 1, j, k);
-                double norm = val < 1 ? 1 : val;
-                m_ietax(i, j, k) /= norm;
-            }
-        }
-    }
-
-    // Cumulative sum in the y direction
-    for (ssize_t i = 0; i < m_ietay.shape(0); i++) {
-        for (ssize_t j = 1; j < m_ietay.shape(1); j++) {
-            for (ssize_t k = 0; k < m_ietay.shape(2); k++) {
-                m_ietay(i, j, k) += m_ietay(i, j - 1, k);
-            }
-        }
-    }
-
-    // Normalize by the highest column, if norm less than 1 don't do anything
-    for (ssize_t i = 0; i < m_ietay.shape(0); i++) {
-        for (ssize_t j = 0; j < m_ietay.shape(1); j++) {
-            for (ssize_t k = 0; k < m_ietay.shape(2); k++) {
-                auto val = m_ietay(i, m_ietay.shape(1) - 1, k);
-                double norm = val < 1 ? 1 : val;
-                m_ietay(i, j, k) /= norm;
-            }
-        }
-    }
-}
-
-std::vector<Photon> Interpolator::interpolate(const ClusterVector<int32_t>& clusters) {
-    std::vector<Photon> photons;
-    photons.reserve(clusters.size());
-
-    if (clusters.cluster_size_x() == 3 || clusters.cluster_size_y() == 3) {
-        for (size_t i = 0; i<clusters.size(); i++){
-
-            auto cluster = clusters.at<Cluster3x3>(i);
-            Eta2 eta= calculate_eta2(cluster);
-    
-            Photon photon;
-            photon.x = cluster.x;
-            photon.y = cluster.y;
-            photon.energy = eta.sum;
-    
-
-            //Finding the index of the last element that is smaller
-            //should work fine as long as we have many bins
-            auto ie = last_smaller(m_energy_bins, photon.energy);
-            auto ix = last_smaller(m_etabinsx, eta.x);
-            auto iy = last_smaller(m_etabinsy, eta.y); 
-            
-            double dX{}, dY{};
-            // cBottomLeft = 0,
-            // cBottomRight = 1,
-            // cTopLeft = 2,
-            // cTopRight = 3
-            switch (eta.c) {
-            case cTopLeft:
-                dX = -1.;
-                dY = 0.;
-                break;
-            case cTopRight:;
-                dX = 0.;
-                dY = 0.;
-                break;
-            case cBottomLeft:
-                dX = -1.;
-                dY = -1.;
-                break;
-            case cBottomRight:
-                dX = 0.; 
-                dY = -1.;
-                break;
-            }
-            photon.x += m_ietax(ix, iy, ie)*2 + dX;
-            photon.y += m_ietay(ix, iy, ie)*2 + dY;
-            photons.push_back(photon);
-        }
-    }else if(clusters.cluster_size_x() == 2 || clusters.cluster_size_y() == 2){
-        for (size_t i = 0; i<clusters.size(); i++){
-            auto cluster = clusters.at<Cluster2x2>(i);
-            Eta2 eta= calculate_eta2(cluster);
-    
-            Photon photon;
-            photon.x = cluster.x;
-            photon.y = cluster.y;
-            photon.energy = eta.sum;
-    
-            //Now do some actual interpolation. 
-            //Find which energy bin the cluster is in
-            // auto ie = nearest_index(m_energy_bins, photon.energy)-1;
-            // auto ix = nearest_index(m_etabinsx, eta.x)-1;
-            // auto iy = nearest_index(m_etabinsy, eta.y)-1;  
-            //Finding the index of the last element that is smaller
-            //should work fine as long as we have many bins
-            auto ie = last_smaller(m_energy_bins, photon.energy);
-            auto ix = last_smaller(m_etabinsx, eta.x);
-            auto iy = last_smaller(m_etabinsy, eta.y); 
-
-            photon.x += m_ietax(ix, iy, ie)*2; //eta goes between 0 and 1 but we could move the hit anywhere in the 2x2
-            photon.y += m_ietay(ix, iy, ie)*2;
-            photons.push_back(photon);
-        }
-        
-    }else{
-        throw std::runtime_error("Only 3x3 and 2x2 clusters are supported for interpolation");
-    }
-  
-
-    return photons;
-}
-
-} // namespace aare

src/JungfrauDataFile.cpp

@@ -1,238 +0,0 @@
-#include "aare/JungfrauDataFile.hpp"
-#include "aare/algorithm.hpp"
-#include "aare/defs.hpp"
-
-#include <cerrno>
-#include <fmt/format.h>
-
-namespace aare {
-
-JungfrauDataFile::JungfrauDataFile(const std::filesystem::path &fname) {
-
-    if (!std::filesystem::exists(fname)) {
-        throw std::runtime_error(LOCATION +
-                                 "File does not exist: " + fname.string());
-    }
-    find_frame_size(fname);
-    parse_fname(fname);
-    scan_files();
-    open_file(m_current_file_index);
-}
-
-
-// FileInterface
-
-Frame JungfrauDataFile::read_frame(){
-    Frame f(rows(), cols(), Dtype::UINT16);
-    read_into(reinterpret_cast<std::byte *>(f.data()), nullptr);
-    return f;
-}
-
-Frame JungfrauDataFile::read_frame(size_t frame_number){
-    seek(frame_number);
-    Frame f(rows(), cols(), Dtype::UINT16);
-    read_into(reinterpret_cast<std::byte *>(f.data()), nullptr);
-    return f;
-}
-
-std::vector<Frame> JungfrauDataFile::read_n(size_t n_frames) {
-    std::vector<Frame> frames;
-    for(size_t i = 0; i < n_frames; ++i){
-        frames.push_back(read_frame());
-    }
-    return frames;
-}
-
-void JungfrauDataFile::read_into(std::byte *image_buf) {
-    read_into(image_buf, nullptr);
-}
-void JungfrauDataFile::read_into(std::byte *image_buf, size_t n_frames) {
-    read_into(image_buf, n_frames, nullptr);
-}   
-
-size_t JungfrauDataFile::frame_number(size_t frame_index) {
-    seek(frame_index);
-    return read_header().framenum;
-}
-
-std::array<ssize_t, 2> JungfrauDataFile::shape() const {
-    return {static_cast<ssize_t>(rows()), static_cast<ssize_t>(cols())};
-}
-
-DetectorType JungfrauDataFile::detector_type() const { return DetectorType::Jungfrau; }
-
-std::string JungfrauDataFile::base_name() const { return m_base_name; }
-
-size_t JungfrauDataFile::bytes_per_frame() { return m_bytes_per_frame; }
-
-size_t JungfrauDataFile::pixels_per_frame() { return m_rows * m_cols; }
-
-size_t JungfrauDataFile::bytes_per_pixel() const { return sizeof(pixel_type); }
-
-size_t JungfrauDataFile::bitdepth() const {
-    return bytes_per_pixel() * bits_per_byte;
-}
-
-void JungfrauDataFile::seek(size_t frame_index) {
-    if (frame_index >= m_total_frames) {
-        throw std::runtime_error(LOCATION + "Frame index out of range: " +
-                                 std::to_string(frame_index));
-    }
-    m_current_frame_index = frame_index;
-    auto file_index = first_larger(m_last_frame_in_file, frame_index);
-
-    if (file_index != m_current_file_index)
-        open_file(file_index);
-
-    auto frame_offset = (file_index)
-                            ? frame_index - m_last_frame_in_file[file_index - 1]
-                            : frame_index;
-    auto byte_offset = frame_offset * (m_bytes_per_frame + header_size);
-    m_fp.seek(byte_offset);
-};
-
-size_t JungfrauDataFile::tell() { return m_current_frame_index; }
-size_t JungfrauDataFile::total_frames() const { return m_total_frames; }
-size_t JungfrauDataFile::rows() const { return m_rows; }
-size_t JungfrauDataFile::cols() const { return m_cols; }
-
-size_t JungfrauDataFile::n_files() const { return m_last_frame_in_file.size(); }
-
-void JungfrauDataFile::find_frame_size(const std::filesystem::path &fname) {
-
-    static constexpr size_t module_data_size =
-        header_size + sizeof(pixel_type) * 512 * 1024;
-    static constexpr size_t half_data_size =
-        header_size + sizeof(pixel_type) * 256 * 1024;
-    static constexpr size_t chip_data_size =
-        header_size + sizeof(pixel_type) * 256 * 256;
-
-    auto file_size = std::filesystem::file_size(fname);
-    if (file_size == 0) {
-        throw std::runtime_error(LOCATION +
-                                 "Cannot guess frame size: file is empty");
-    }
-
-    if (file_size % module_data_size == 0) {
-        m_rows = 512;
-        m_cols = 1024;
-        m_bytes_per_frame = module_data_size - header_size;
-    } else if (file_size % half_data_size == 0) {
-        m_rows = 256;
-        m_cols = 1024;
-        m_bytes_per_frame = half_data_size - header_size;
-    } else if (file_size % chip_data_size == 0) {
-        m_rows = 256;
-        m_cols = 256;
-        m_bytes_per_frame = chip_data_size - header_size;
-    } else {
-        throw std::runtime_error(LOCATION +
-                                 "Cannot find frame size: file size is not a "
-                                 "multiple of any known frame size");
-    }
-}
-
-void JungfrauDataFile::parse_fname(const std::filesystem::path &fname) {
-    m_path = fname.parent_path();
-    m_base_name = fname.stem();
-
-    // find file index, then remove if from the base name
-    if (auto pos = m_base_name.find_last_of('_'); pos != std::string::npos) {
-        m_offset = std::stoul(m_base_name.substr(pos + 1));
-        m_base_name.erase(pos);
-    }
-}
-
-void JungfrauDataFile::scan_files() {
-    // find how many files we have and the number of frames in each file
-    m_last_frame_in_file.clear();
-    size_t file_index = m_offset;
-    while (std::filesystem::exists(fpath(file_index))) {
-        auto n_frames = std::filesystem::file_size(fpath(file_index)) /
-                        (m_bytes_per_frame + header_size);
-        m_last_frame_in_file.push_back(n_frames);
-        ++file_index;
-    }
-
-    // find where we need to open the next file and total number of frames
-    m_last_frame_in_file = cumsum(m_last_frame_in_file);
-    m_total_frames = m_last_frame_in_file.back();
-}
-
-void JungfrauDataFile::read_into(std::byte *image_buf,
-                                 JungfrauDataHeader *header) {
-
-    // read header if not passed nullptr
-    if (header) {
-        if (auto rc = fread(header, sizeof(JungfrauDataHeader), 1, m_fp.get());
-            rc != 1) {
-            throw std::runtime_error(
-                LOCATION +
-                "Could not read header from file:" + m_fp.error_msg());
-        }
-    } else {
-        m_fp.seek(header_size, SEEK_CUR);
-    }
-
-    // read data
-    if (auto rc = fread(image_buf, 1, m_bytes_per_frame, m_fp.get());
-        rc != m_bytes_per_frame) {
-        throw std::runtime_error(LOCATION + "Could not read image from file" +
-                                 m_fp.error_msg());
-    }
-
-    // prepare for next read
-    // if we are at the end of the file, open the next file
-    ++m_current_frame_index;
-    if (m_current_frame_index >= m_last_frame_in_file[m_current_file_index] &&
-        (m_current_frame_index < m_total_frames)) {
-        ++m_current_file_index;
-        open_file(m_current_file_index);
-    }
-}
-
-void JungfrauDataFile::read_into(std::byte *image_buf, size_t n_frames,
-                                 JungfrauDataHeader *header) {
-    if (header) {
-        for (size_t i = 0; i < n_frames; ++i)
-            read_into(image_buf + i * m_bytes_per_frame, header + i); 
-    }else{
-        for (size_t i = 0; i < n_frames; ++i)
-            read_into(image_buf + i * m_bytes_per_frame, nullptr);
-    }
-}
-
-void JungfrauDataFile::read_into(NDArray<uint16_t>* image, JungfrauDataHeader* header) {
-    if(image->shape()!=shape()){
-        throw std::runtime_error(LOCATION +
-            "Image shape does not match file size: " + std::to_string(rows()) + "x" + std::to_string(cols()));
-    }
-    read_into(reinterpret_cast<std::byte *>(image->data()), header);
-}
-
-
-JungfrauDataHeader JungfrauDataFile::read_header() {
-    JungfrauDataHeader header;
-    if (auto rc = fread(&header, 1, sizeof(header), m_fp.get());
-        rc != sizeof(header)) {
-        throw std::runtime_error(LOCATION + "Could not read header from file" +
-                                 m_fp.error_msg());
-    }
-    m_fp.seek(-header_size, SEEK_CUR);
-    return header;
-}
-
-void JungfrauDataFile::open_file(size_t file_index) {
-    // fmt::print(stderr, "Opening file: {}\n",
-    // fpath(file_index+m_offset).string());
-    m_fp = FilePtr(fpath(file_index + m_offset), "rb");
-    m_current_file_index = file_index;
-}
-
-std::filesystem::path JungfrauDataFile::fpath(size_t file_index) const {
-    auto fname = fmt::format("{}_{:0{}}.dat", m_base_name, file_index,
-                             n_digits_in_file_index);
-    return m_path / fname;
-}
-
-} // namespace aare

src/JungfrauDataFile.test.cpp

@@ -1,114 +0,0 @@
-#include "aare/JungfrauDataFile.hpp"
-
-#include <catch2/catch_test_macros.hpp>
-#include "test_config.hpp"
-
-using aare::JungfrauDataFile;
-using aare::JungfrauDataHeader;
-TEST_CASE("Open a Jungfrau data file", "[.files]") {
-    //we know we have 4 files with 7, 7, 7, and 3 frames
-    //firs frame number if 1 and the bunch id is frame_number**2
-    //so we can check the header
-    auto fpath = test_data_path() / "dat" / "AldoJF500k_000000.dat";
-    REQUIRE(std::filesystem::exists(fpath));
-
-    JungfrauDataFile f(fpath);
-    REQUIRE(f.rows() == 512);
-    REQUIRE(f.cols() == 1024);
-    REQUIRE(f.bytes_per_frame() == 1048576);    
-    REQUIRE(f.pixels_per_frame() == 524288);
-    REQUIRE(f.bytes_per_pixel() == 2);
-    REQUIRE(f.bitdepth() == 16);
-    REQUIRE(f.base_name() == "AldoJF500k");
-    REQUIRE(f.n_files() == 4);
-    REQUIRE(f.tell() == 0);
-    REQUIRE(f.total_frames() == 24);
-    REQUIRE(f.current_file() == fpath);
-
-    //Check that the frame number and buch id is read correctly
-    for (size_t i = 0; i < 24; ++i) {
-        JungfrauDataHeader header;
-        aare::NDArray<uint16_t> image(f.shape());
-        f.read_into(&image, &header);
-        REQUIRE(header.framenum == i + 1);
-        REQUIRE(header.bunchid == (i + 1) * (i + 1));
-        REQUIRE(image.shape(0) == 512);
-        REQUIRE(image.shape(1) == 1024);
-    }
-}
-
-TEST_CASE("Seek in a JungfrauDataFile", "[.files]"){
-    auto fpath = test_data_path() / "dat" / "AldoJF65k_000000.dat";
-    REQUIRE(std::filesystem::exists(fpath));
-
-    JungfrauDataFile f(fpath);
-
-    //The file should have 113 frames
-    f.seek(19);
-    REQUIRE(f.tell() == 19);
-    auto h = f.read_header();
-    REQUIRE(h.framenum == 19+1);
-
-    //Reading again does not change the file pointer
-    auto h2 = f.read_header();
-    REQUIRE(h2.framenum == 19+1);
-
-    f.seek(59);
-    REQUIRE(f.tell() == 59);
-    auto h3 = f.read_header();
-    REQUIRE(h3.framenum == 59+1);
-
-    JungfrauDataHeader h4;
-    aare::NDArray<uint16_t> image(f.shape());
-    f.read_into(&image, &h4);
-    REQUIRE(h4.framenum == 59+1);
-
-    //now we should be on the next frame
-    REQUIRE(f.tell() == 60);
-    REQUIRE(f.read_header().framenum == 60+1);
-
-    REQUIRE_THROWS(f.seek(86356)); //out of range
-}
-
-TEST_CASE("Open a Jungfrau data file with non zero file index", "[.files]"){
-
-    auto fpath = test_data_path() / "dat" / "AldoJF65k_000003.dat";
-    REQUIRE(std::filesystem::exists(fpath));
-
-    JungfrauDataFile f(fpath);
-
-    //18 files per data file, opening the 3rd file we ignore the first 3
-    REQUIRE(f.total_frames() == 113-18*3);
-    REQUIRE(f.tell() == 0);
-
-    //Frame numbers start at 1 in the first file
-    REQUIRE(f.read_header().framenum == 18*3+1);
-
-    // moving relative to the third file
-    f.seek(5);
-    REQUIRE(f.read_header().framenum == 18*3+1+5);
-
-    // ignoring the first 3 files
-    REQUIRE(f.n_files() == 4);
-
-    REQUIRE(f.current_file().stem() == "AldoJF65k_000003");
-
-}
-
-TEST_CASE("Read into throws if size doesn't match", "[.files]"){
-    auto fpath = test_data_path() / "dat" / "AldoJF65k_000000.dat";
-    REQUIRE(std::filesystem::exists(fpath));
-
-    JungfrauDataFile f(fpath);
-
-    aare::NDArray<uint16_t> image({39, 85});
-    JungfrauDataHeader header;
-
-    REQUIRE_THROWS(f.read_into(&image, &header));
-    REQUIRE_THROWS(f.read_into(&image, nullptr));
-    REQUIRE_THROWS(f.read_into(&image));
-
-    REQUIRE(f.tell() == 0);
-
-
-}

src/NDArray.test.cpp

@@ -2,7 +2,6 @@
 #include <array>
 #include <catch2/benchmark/catch_benchmark.hpp>
 #include <catch2/catch_test_macros.hpp>
-#include <numeric>
 
 using aare::NDArray;
 using aare::NDView;
@@ -35,24 +34,6 @@ TEST_CASE("Construct from an NDView") {
     }
 }
 
-TEST_CASE("3D NDArray from NDView"){
-    std::vector<int> data(27);
-    std::iota(data.begin(), data.end(), 0);
-    NDView<int, 3> view(data.data(), Shape<3>{3, 3, 3});
-    NDArray<int, 3> image(view);
-    REQUIRE(image.shape() == view.shape());
-    REQUIRE(image.size() == view.size());
-    REQUIRE(image.data() != view.data());
-
-    for(int64_t i=0; i<image.shape(0); i++){
-        for(int64_t j=0; j<image.shape(1); j++){
-            for(int64_t k=0; k<image.shape(2); k++){
-                REQUIRE(image(i, j, k) == view(i, j, k));
-            }
-        }
-    }
-}
-
 TEST_CASE("1D image") {
     std::array<int64_t, 1> shape{{20}};
     NDArray<short, 1> img(shape, 3);
@@ -183,14 +164,14 @@ TEST_CASE("Size and shape matches") {
     int64_t h = 75;
     std::array<int64_t, 2> shape{w, h};
     NDArray<double> a{shape};
-    REQUIRE(a.size() == w * h);
+    REQUIRE(a.size() == static_cast<uint64_t>(w * h));
     REQUIRE(a.shape() == shape);
 }
 
 TEST_CASE("Initial value matches for all elements") {
     double v = 4.35;
     NDArray<double> a{{5, 5}, v};
-    for (int i = 0; i < a.size(); ++i) {
+    for (uint32_t i = 0; i < a.size(); ++i) {
         REQUIRE(a(i) == v);
     }
 }
@@ -398,32 +379,4 @@ TEST_CASE("Elementwise operations on images") {
             REQUIRE(A(i) == a_val);
         }
     }
-}
-
-TEST_CASE("Assign an std::array to a 1D NDArray") {
-    NDArray<int, 1> a{{5}, 0};
-    std::array<int, 5> b{1, 2, 3, 4, 5};
-    a = b;
-    for (uint32_t i = 0; i < a.size(); ++i) {
-        REQUIRE(a(i) == b[i]);
-    }
-}
-
-TEST_CASE("Assign an std::array to a 1D NDArray of a different size") {
-    NDArray<int, 1> a{{3}, 0};
-    std::array<int, 5> b{1, 2, 3, 4, 5};
-    a = b;
-
-    REQUIRE(a.size() == 5);
-    for (uint32_t i = 0; i < a.size(); ++i) {
-        REQUIRE(a(i) == b[i]);
-    }
-}
-
-TEST_CASE("Construct an NDArray from an std::array") {
-    std::array<int, 5> b{1, 2, 3, 4, 5};
-    NDArray<int, 1> a(b);
-    for (uint32_t i = 0; i < a.size(); ++i) {
-        REQUIRE(a(i) == b[i]);
-    }
 }

src/NDView.test.cpp

@@ -3,7 +3,6 @@
 
 #include <iostream>
 #include <vector>
-#include <numeric>
 
 using aare::NDView;
 using aare::Shape;
@@ -22,8 +21,10 @@ TEST_CASE("Element reference 1D") {
 }
 
 TEST_CASE("Element reference 2D") {
-    std::vector<int> vec(12);
-    std::iota(vec.begin(), vec.end(), 0);
+    std::vector<int> vec;
+    for (int i = 0; i != 12; ++i) {
+        vec.push_back(i);
+    }
 
     NDView<int, 2> data(vec.data(), Shape<2>{3, 4});
     REQUIRE(vec.size() == static_cast<size_t>(data.size()));
@@ -57,8 +58,10 @@ TEST_CASE("Element reference 3D") {
 }
 
 TEST_CASE("Plus and miuns with single value") {
-    std::vector<int> vec(12);
-    std::iota(vec.begin(), vec.end(), 0);
+    std::vector<int> vec;
+    for (int i = 0; i != 12; ++i) {
+        vec.push_back(i);
+    }
     NDView<int, 2> data(vec.data(), Shape<2>{3, 4});
     data += 5;
     int i = 0;
@@ -113,8 +116,10 @@ TEST_CASE("elementwise assign") {
 }
 
 TEST_CASE("iterators") {
-    std::vector<int> vec(12);
-    std::iota(vec.begin(), vec.end(), 0);
+    std::vector<int> vec;
+    for (int i = 0; i != 12; ++i) {
+        vec.push_back(i);
+    }
     NDView<int, 1> data(vec.data(), Shape<1>{12});
     int i = 0;
     for (const auto item : data) {
@@ -162,31 +167,27 @@ TEST_CASE("divide with another span") {
 }
 
 TEST_CASE("Retrieve shape") {
-    std::vector<int> vec(12);
-    std::iota(vec.begin(), vec.end(), 0);
+    std::vector<int> vec;
+    for (int i = 0; i != 12; ++i) {
+        vec.push_back(i);
+    }
     NDView<int, 2> data(vec.data(), Shape<2>{3, 4});
     REQUIRE(data.shape()[0] == 3);
     REQUIRE(data.shape()[1] == 4);
 }
 
 TEST_CASE("compare two views") {
-    std::vector<int> vec1(12);
-    std::iota(vec1.begin(), vec1.end(), 0);
+    std::vector<int> vec1;
+    for (int i = 0; i != 12; ++i) {
+        vec1.push_back(i);
+    }
     NDView<int, 2> view1(vec1.data(), Shape<2>{3, 4});
 
-    std::vector<int> vec2(12);
-    std::iota(vec2.begin(), vec2.end(), 0);
+    std::vector<int> vec2;
+    for (int i = 0; i != 12; ++i) {
+        vec2.push_back(i);
+    }
     NDView<int, 2> view2(vec2.data(), Shape<2>{3, 4});
 
     REQUIRE((view1 == view2));
-}
-
-
-TEST_CASE("Create a view over a vector"){
-    std::vector<int> vec(12);
-    std::iota(vec.begin(), vec.end(), 0);
-    auto v = aare::make_view(vec);
-    REQUIRE(v.shape()[0] == 12);
-    REQUIRE(v[0] == 0);
-    REQUIRE(v[11] == 11);
 }

src/RawFile.cpp

@@ -1,7 +1,6 @@
 #include "aare/RawFile.hpp"
 #include "aare/PixelMap.hpp"
 #include "aare/defs.hpp"
-#include "aare/geo_helpers.hpp"
 
 #include <fmt/format.h>
 #include <nlohmann/json.hpp>
@@ -22,11 +21,8 @@ RawFile::RawFile(const std::filesystem::path &fname, const std::string &mode)
         
 
         find_geometry();
+        update_geometry_with_roi();
 
-        if (m_master.roi()){
-            m_geometry = update_geometry_with_roi(m_geometry, m_master.roi().value());
-        }
-        
         open_subfiles();
     } else {
         throw std::runtime_error(LOCATION +
@@ -76,12 +72,9 @@ size_t RawFile::n_mod() const { return n_subfile_parts; }
 
 
 size_t RawFile::bytes_per_frame() {
-    return m_geometry.pixels_x * m_geometry.pixels_y * m_master.bitdepth() / bits_per_byte;
-}
-size_t RawFile::pixels_per_frame() { 
-    // return m_rows * m_cols; 
-    return m_geometry.pixels_x * m_geometry.pixels_y;
+    return m_rows * m_cols * m_master.bitdepth() / 8;
 }
+size_t RawFile::pixels_per_frame() { return m_rows * m_cols; }
 
 DetectorType RawFile::detector_type() const { return m_master.detector_type(); }
 
@@ -99,8 +92,8 @@ void RawFile::seek(size_t frame_index) {
 size_t RawFile::tell() { return m_current_frame; };
 
 size_t RawFile::total_frames() const { return m_master.frames_in_file(); }
-size_t RawFile::rows() const { return m_geometry.pixels_y; }
-size_t RawFile::cols() const { return m_geometry.pixels_x; }
+size_t RawFile::rows() const { return m_rows; }
+size_t RawFile::cols() const { return m_cols; }
 size_t RawFile::bitdepth() const { return m_master.bitdepth(); }
 xy RawFile::geometry() { return m_master.geometry(); }
 
@@ -109,11 +102,11 @@ void RawFile::open_subfiles() {
         for (size_t i = 0; i != n_subfiles; ++i) {
             auto v = std::vector<RawSubFile *>(n_subfile_parts);
             for (size_t j = 0; j != n_subfile_parts; ++j) {
-                auto pos = m_geometry.module_pixel_0[j];
+                auto pos = m_module_pixel_0[j];
                 v[j] = new RawSubFile(m_master.data_fname(j, i),
                                       m_master.detector_type(), pos.height,
                                       pos.width, m_master.bitdepth(),
-                                      pos.row_index, pos.col_index);
+                                      positions[j].row, positions[j].col);
 
             }
             subfiles.push_back(v);
@@ -156,49 +149,112 @@ int RawFile::find_number_of_subfiles() {
 
 RawMasterFile RawFile::master() const { return m_master; }
 
-/**
- * @brief Find the geometry of the detector by opening all the subfiles and
- * reading the headers. 
- */
 void RawFile::find_geometry() {
-    
-    //Hold the maximal row and column number found
-    //Later used for calculating the total number of rows and columns
     uint16_t r{};
     uint16_t c{};
 
 
     for (size_t i = 0; i < n_subfile_parts; i++) {
-        auto h = read_header(m_master.data_fname(i, 0));
+        auto h = this->read_header(m_master.data_fname(i, 0));
         r = std::max(r, h.row);
         c = std::max(c, h.column);
-        // positions.push_back({h.row, h.column});
-       
+        positions.push_back({h.row, h.column});
         ModuleGeometry g;
-        g.origin_x = h.column * m_master.pixels_x();
-        g.origin_y = h.row * m_master.pixels_y();
-        g.row_index = h.row;
-        g.col_index = h.column;
+        g.x = h.column * m_master.pixels_x();
+        g.y = h.row * m_master.pixels_y();
         g.width = m_master.pixels_x();
         g.height = m_master.pixels_y();
-        m_geometry.module_pixel_0.push_back(g);
+        m_module_pixel_0.push_back(g);
 
     }
 
     r++;
     c++;
 
-    m_geometry.pixels_y = (r * m_master.pixels_y());
-    m_geometry.pixels_x  = (c * m_master.pixels_x());
-    m_geometry.modules_x = c;
-    m_geometry.modules_y = r;
-    m_geometry.pixels_y += static_cast<size_t>((r - 1) * cfg.module_gap_row);
+    m_rows = (r * m_master.pixels_y());
+    m_cols = (c * m_master.pixels_x());
+
+    m_rows += static_cast<size_t>((r - 1) * cfg.module_gap_row);
+
+#ifdef AARE_VERBOSE
+    fmt::print("\nRawFile::find_geometry()\n");
+    for (size_t i = 0; i < m_module_pixel_0.size(); i++) {
+        fmt::print("Module {} at position: (r:{},c:{})\n", i,
+                   m_module_pixel_0[i].y, m_module_pixel_0[i].x);
+    }
+    fmt::print("Image size: {}x{}\n\n", m_rows, m_cols);
+#endif
+}
+
+void RawFile::update_geometry_with_roi() {
+    // TODO! implement this
+    if (m_master.roi()) {
+        auto roi = m_master.roi().value();
+
+        // TODO! can we do this cleaner?
+        int pos_y = 0;
+        int pos_y_increment = 0;
+        for (size_t row = 0; row < m_master.geometry().row; row++) {
+            int pos_x = 0;
+            for (size_t col = 0; col < m_master.geometry().col; col++) {
+                auto &m = m_module_pixel_0[row * m_master.geometry().col + col];
+                auto original_height = m.height;
+                auto original_width = m.width;
+
+                // module is to the left of the roi
+                if (m.x + m.width < roi.xmin) {
+                    m.width = 0;
+
+                    // roi is in module
+                } else {
+                    // here we only arrive when the roi is in or to the left of
+                    // the module
+                    if (roi.xmin > m.x) {
+                        m.width -= roi.xmin - m.x;
+                    }
+                    if (roi.xmax < m.x + m.width) {
+                        m.width -= m.x + original_width - roi.xmax;
+                    }
+                    m.x = pos_x;
+                    pos_x += m.width;
+                }
+
+                if (m.y + m.height < roi.ymin) {
+                    m.height = 0;
+                } else {
+                    if ((roi.ymin > m.y) && (roi.ymin < m.y + m.height)) {
+                        m.height -= roi.ymin - m.y;
+
+                    }
+                    if (roi.ymax < m.y + m.height) {
+                        m.height -= m.y + original_height - roi.ymax;
+                    }
+                    m.y = pos_y;
+                    pos_y_increment = m.height;
+                }
+            }
+            // increment pos_y
+            pos_y += pos_y_increment;
+        }
+
+        m_rows = roi.height();
+        m_cols = roi.width();
+    }
+
+#ifdef AARE_VERBOSE
+    fmt::print("RawFile::update_geometry_with_roi()\n");
+    for (const auto &m : m_module_pixel_0) {
+        fmt::print("Module at position: (r:{}, c:{}, h:{}, w:{})\n", m.y, m.x,
+                   m.height, m.width);
+    }
+    fmt::print("Updated image size: {}x{}\n\n", m_rows, m_cols);
+    fmt::print("\n");
+#endif
 
 }
 
-
 Frame RawFile::get_frame(size_t frame_index) {
-    auto f = Frame(m_geometry.pixels_y, m_geometry.pixels_x, Dtype::from_bitdepth(m_master.bitdepth()));
+    auto f = Frame(m_rows, m_cols, Dtype::from_bitdepth(m_master.bitdepth()));
     std::byte *frame_buffer = f.data();
     get_frame_into(frame_index, frame_buffer);
     return f;
@@ -222,10 +278,6 @@ void RawFile::get_frame_into(size_t frame_index, std::byte *frame_buffer, Detect
     if (n_subfile_parts != 1) {
         for (size_t part_idx = 0; part_idx != n_subfile_parts; ++part_idx) {
             auto subfile_id = frame_index / m_master.max_frames_per_file();
-            if (subfile_id >= subfiles.size()) {
-                throw std::runtime_error(LOCATION +
-                                         " Subfile out of range. Possible missing data.");
-            }
             frame_numbers[part_idx] =
                 subfiles[subfile_id][part_idx]->frame_number(
                     frame_index % m_master.max_frames_per_file());
@@ -259,16 +311,12 @@ void RawFile::get_frame_into(size_t frame_index, std::byte *frame_buffer, Detect
         for (size_t part_idx = 0; part_idx != n_subfile_parts; ++part_idx) {
             auto corrected_idx = frame_indices[part_idx];
             auto subfile_id = corrected_idx / m_master.max_frames_per_file();
-            if (subfile_id >= subfiles.size()) {
-                throw std::runtime_error(LOCATION +
-                                         " Subfile out of range. Possible missing data.");
-            }
 
             // This is where we start writing
-            auto offset = (m_geometry.module_pixel_0[part_idx].origin_y * m_geometry.pixels_x +
-                m_geometry.module_pixel_0[part_idx].origin_x)*m_master.bitdepth()/8;
+            auto offset = (m_module_pixel_0[part_idx].y * m_cols +
+                          m_module_pixel_0[part_idx].x)*m_master.bitdepth()/8;
 
-            if (m_geometry.module_pixel_0[part_idx].origin_x!=0)
+            if (m_module_pixel_0[part_idx].x!=0)
                 throw std::runtime_error(LOCATION + "Implementation error. x pos not 0.");
             
             //TODO! Risk for out of range access
@@ -292,13 +340,9 @@ void RawFile::get_frame_into(size_t frame_index, std::byte *frame_buffer, Detect
         // level
 
         for (size_t part_idx = 0; part_idx != n_subfile_parts; ++part_idx) {
-            auto pos = m_geometry.module_pixel_0[part_idx];
+            auto pos = m_module_pixel_0[part_idx];
             auto corrected_idx = frame_indices[part_idx];
             auto subfile_id = corrected_idx / m_master.max_frames_per_file();
-            if (subfile_id >= subfiles.size()) {
-                throw std::runtime_error(LOCATION +
-                                         " Subfile out of range. Possible missing data.");
-            }
 
             subfiles[subfile_id][part_idx]->seek(corrected_idx % m_master.max_frames_per_file());
             subfiles[subfile_id][part_idx]->read_into(part_buffer, header);
@@ -308,9 +352,9 @@ void RawFile::get_frame_into(size_t frame_index, std::byte *frame_buffer, Detect
             for (size_t cur_row = 0; cur_row < static_cast<size_t>(pos.height);
                  cur_row++) {
 
-                auto irow = (pos.origin_y + cur_row);
-                auto icol = pos.origin_x;
-                auto dest = (irow * this->m_geometry.pixels_x + icol);
+                auto irow = (pos.y + cur_row);
+                auto icol = pos.x;
+                auto dest = (irow * this->m_cols + icol);
                 dest = dest * m_master.bitdepth() / 8;
                 memcpy(frame_buffer + dest,
                        part_buffer + cur_row * pos.width *
@@ -356,8 +400,4 @@ RawFile::~RawFile() {
     }
 }
 
-
-
-
-
 } // namespace aare

src/RawFile.test.cpp

@@ -1,13 +1,10 @@
 #include "aare/File.hpp"
-#include "aare/RawMasterFile.hpp" //needed for ROI
-#include "aare/RawFile.hpp"
 
 #include <catch2/catch_test_macros.hpp>
 #include <filesystem>
 
 #include "test_config.hpp"
 
-
 using aare::File;
 
 TEST_CASE("Read number of frames from a jungfrau raw file", "[.integration]") {
@@ -151,5 +148,3 @@ TEST_CASE("Read file with unordered frames", "[.integration]") {
     File f(fpath);
     REQUIRE_THROWS((f.read_frame()));
 }
-
-

src/RawSubFile.cpp

@@ -1,29 +1,24 @@
 #include "aare/RawSubFile.hpp"
 #include "aare/PixelMap.hpp"
-#include "aare/utils/ifstream_helpers.hpp"
 #include <cstring> // memcpy
 #include <fmt/core.h>
 #include <iostream>
 
-
-
 namespace aare {
 
 RawSubFile::RawSubFile(const std::filesystem::path &fname,
                        DetectorType detector, size_t rows, size_t cols,
                        size_t bitdepth, uint32_t pos_row, uint32_t pos_col)
-    : m_detector_type(detector), m_bitdepth(bitdepth), m_fname(fname),
-      m_rows(rows), m_cols(cols),
-      m_bytes_per_frame((m_bitdepth / 8) * m_rows * m_cols), m_pos_row(pos_row),
-      m_pos_col(pos_col) {
+    : m_detector_type(detector), m_bitdepth(bitdepth), m_fname(fname), m_rows(rows), m_cols(cols),
+      m_bytes_per_frame((m_bitdepth / 8) * m_rows * m_cols), m_pos_row(pos_row), m_pos_col(pos_col) {
     if (m_detector_type == DetectorType::Moench03_old) {
         m_pixel_map = GenerateMoench03PixelMap();
-    } else if (m_detector_type == DetectorType::Eiger && m_pos_row % 2 == 0) {
+    }else if(m_detector_type == DetectorType::Eiger && m_pos_row % 2 == 0){
         m_pixel_map = GenerateEigerFlipRowsPixelMap();
     }
 
     if (std::filesystem::exists(fname)) {
-        m_num_frames = std::filesystem::file_size(fname) /
+        n_frames = std::filesystem::file_size(fname) /
                    (sizeof(DetectorHeader) + rows * cols * bitdepth / 8);
     } else {
         throw std::runtime_error(
@@ -38,7 +33,7 @@ RawSubFile::RawSubFile(const std::filesystem::path &fname,
     }
 
 #ifdef AARE_VERBOSE
-    fmt::print("Opened file: {} with {} frames\n", m_fname.string(), m_num_frames);
+    fmt::print("Opened file: {} with {} frames\n", m_fname.string(), n_frames);
     fmt::print("m_rows: {}, m_cols: {}, m_bitdepth: {}\n", m_rows, m_cols,
                m_bitdepth);
     fmt::print("file size: {}\n", std::filesystem::file_size(fname));
@@ -46,8 +41,8 @@ RawSubFile::RawSubFile(const std::filesystem::path &fname,
 }
 
 void RawSubFile::seek(size_t frame_index) {
-    if (frame_index >= m_num_frames) {
-        throw std::runtime_error(LOCATION + fmt::format("Frame index {} out of range in a file with {} frames", frame_index, m_num_frames));
+    if (frame_index >= n_frames) {
+        throw std::runtime_error("Frame number out of range");
     }
     m_file.seekg((sizeof(DetectorHeader) + bytes_per_frame()) * frame_index);
 }
@@ -56,68 +51,37 @@ size_t RawSubFile::tell() {
     return m_file.tellg() / (sizeof(DetectorHeader) + bytes_per_frame());
 }
 
+
 void RawSubFile::read_into(std::byte *image_buf, DetectorHeader *header) {
-    if (header) {
-        m_file.read(reinterpret_cast<char *>(header), sizeof(DetectorHeader));
+    if(header){
+         m_file.read(reinterpret_cast<char *>(header), sizeof(DetectorHeader));
     } else {
         m_file.seekg(sizeof(DetectorHeader), std::ios::cur);
     }
 
-    if (m_file.fail()){
-        throw std::runtime_error(LOCATION + ifstream_error_msg(m_file));
-    }
-
-    // TODO! expand support for different bitdepths
-    if (m_pixel_map) {
+    //TODO! expand support for different bitdepths
+    if(m_pixel_map){
         // read into a temporary buffer and then copy the data to the buffer
         // in the correct order
-        // TODO! add 4 bit support
-        if(m_bitdepth == 8){
-            read_with_map<uint8_t>(image_buf);
-        }else if (m_bitdepth == 16) {
-            read_with_map<uint16_t>(image_buf);
-        } else if (m_bitdepth == 32) {
-            read_with_map<uint32_t>(image_buf);
-        }else{
-            throw std::runtime_error("Unsupported bitdepth for read with pixel map");
+        // currently this only supports 16 bit data!
+        auto part_buffer = new std::byte[bytes_per_frame()];
+        m_file.read(reinterpret_cast<char *>(part_buffer), bytes_per_frame());
+        auto *data = reinterpret_cast<uint16_t *>(image_buf);
+        auto *part_data = reinterpret_cast<uint16_t *>(part_buffer);
+        for (size_t i = 0; i < pixels_per_frame(); i++) {
+            data[i] = part_data[(*m_pixel_map)(i)];
         }
-
+        delete[] part_buffer;
     } else {
         // read directly into the buffer
         m_file.read(reinterpret_cast<char *>(image_buf), bytes_per_frame());
     }
-
-    if (m_file.fail()){
-        throw std::runtime_error(LOCATION + ifstream_error_msg(m_file));
-    }
 }
 
-void RawSubFile::read_into(std::byte *image_buf, size_t n_frames, DetectorHeader *header) {
-    for (size_t i = 0; i < n_frames; i++) {
-        read_into(image_buf, header);
-        image_buf += bytes_per_frame();
-        if (header) {
-            ++header;
-        }
-    }
-}
-
-
-
-template <typename T>
-void RawSubFile::read_with_map(std::byte *image_buf) {
-    auto part_buffer = new std::byte[bytes_per_frame()];
-    m_file.read(reinterpret_cast<char *>(part_buffer), bytes_per_frame());
-    auto *data = reinterpret_cast<T *>(image_buf);
-    auto *part_data = reinterpret_cast<T *>(part_buffer);
-    for (size_t i = 0; i < pixels_per_frame(); i++) {
-        data[i] = part_data[(*m_pixel_map)(i)];
-    }
-    delete[] part_buffer;
-}
 size_t RawSubFile::rows() const { return m_rows; }
 size_t RawSubFile::cols() const { return m_cols; }
 
+
 void RawSubFile::get_part(std::byte *buffer, size_t frame_index) {
     seek(frame_index);
     read_into(buffer, nullptr);
@@ -130,4 +94,5 @@ size_t RawSubFile::frame_number(size_t frame_index) {
     return h.frameNumber;
 }
 
+
 } // namespace aare

src/algorithm.test.cpp

@@ -1,159 +0,0 @@
-
-
-#include <catch2/catch_test_macros.hpp>
-#include <aare/algorithm.hpp>
-
-
-TEST_CASE("Find the closed index in a 1D array", "[algorithm]") {
-    aare::NDArray<double, 1> arr({5});
-    for (ssize_t i = 0; i < arr.size(); i++) {
-        arr[i] = i;
-    }
-    // arr 0, 1, 2, 3, 4
-    REQUIRE(aare::nearest_index(arr, 2.3) == 2);
-    REQUIRE(aare::nearest_index(arr, 2.6) == 3);
-    REQUIRE(aare::nearest_index(arr, 45.0) == 4);
-    REQUIRE(aare::nearest_index(arr, 0.0) == 0);
-    REQUIRE(aare::nearest_index(arr, -1.0) == 0);
-}
-
-TEST_CASE("Passing integers to nearest_index works", "[algorithm]"){
-    aare::NDArray<int, 1> arr({5});
-    for (ssize_t i = 0; i < arr.size(); i++) {
-        arr[i] = i;
-    }
-    // arr 0, 1, 2, 3, 4
-    REQUIRE(aare::nearest_index(arr, 2) == 2);
-    REQUIRE(aare::nearest_index(arr, 3) == 3);
-    REQUIRE(aare::nearest_index(arr, 45) == 4);
-    REQUIRE(aare::nearest_index(arr, 0) == 0);
-    REQUIRE(aare::nearest_index(arr, -1) == 0);
-}
-
-
-TEST_CASE("nearest_index works with std::vector", "[algorithm]"){
-    std::vector<double> vec = {0, 1, 2, 3, 4};
-    REQUIRE(aare::nearest_index(vec, 2.123) == 2);
-    REQUIRE(aare::nearest_index(vec, 2.66) == 3);
-    REQUIRE(aare::nearest_index(vec, 4555555.0) == 4);
-    REQUIRE(aare::nearest_index(vec, 0.0) == 0);
-    REQUIRE(aare::nearest_index(vec, -10.0) == 0);
-}
-
-TEST_CASE("nearest index works with std::array", "[algorithm]"){
-    std::array<double, 5> arr = {0, 1, 2, 3, 4};
-    REQUIRE(aare::nearest_index(arr, 2.123) == 2);
-    REQUIRE(aare::nearest_index(arr, 2.501) == 3);
-    REQUIRE(aare::nearest_index(arr, 4555555.0) == 4);
-    REQUIRE(aare::nearest_index(arr, 0.0) == 0);
-    REQUIRE(aare::nearest_index(arr, -10.0) == 0);
-}
-
-TEST_CASE("nearest index when there is no different uses the first element", "[algorithm]"){
-    std::vector<int> vec = {5, 5, 5, 5, 5};
-    REQUIRE(aare::nearest_index(vec, 5) == 0);
-}
-
-TEST_CASE("nearest index when there is no different uses the first element also when all smaller", "[algorithm]"){
-    std::vector<int> vec = {5, 5, 5, 5, 5};
-    REQUIRE(aare::nearest_index(vec, 10) == 0);
-}
-
-
-TEST_CASE("last smaller", "[algorithm]"){
-    aare::NDArray<double, 1> arr({5});
-    for (ssize_t i = 0; i < arr.size(); i++) {
-        arr[i] = i;
-    }
-    // arr 0, 1, 2, 3, 4
-    REQUIRE(aare::last_smaller(arr, -10.0) == 0);
-    REQUIRE(aare::last_smaller(arr, 0.0) == 0);
-    REQUIRE(aare::last_smaller(arr, 2.3) == 2);
-    REQUIRE(aare::last_smaller(arr, 253.) == 4);
-}
-
-TEST_CASE("returns last bin strictly smaller", "[algorithm]"){
-    aare::NDArray<double, 1> arr({5});
-    for (ssize_t i = 0; i < arr.size(); i++) {
-        arr[i] = i;
-    }
-    // arr 0, 1, 2, 3, 4
-    REQUIRE(aare::last_smaller(arr, 2.0) == 1);
-
-}
-
-TEST_CASE("last_smaller with all elements smaller returns last element", "[algorithm]"){
-    aare::NDArray<double, 1> arr({5});
-    for (ssize_t i = 0; i < arr.size(); i++) {
-        arr[i] = i;
-    }
-    // arr 0, 1, 2, 3, 4
-    REQUIRE(aare::last_smaller(arr, 50.) == 4);
-}
-
-TEST_CASE("last_smaller with all elements bigger returns first element", "[algorithm]"){
-    aare::NDArray<double, 1> arr({5});
-    for (ssize_t i = 0; i < arr.size(); i++) {
-        arr[i] = i;
-    }
-    // arr 0, 1, 2, 3, 4
-    REQUIRE(aare::last_smaller(arr, -50.) == 0);
-}
-
-TEST_CASE("last smaller with all elements equal returns the first element", "[algorithm]"){
-    std::vector<int> vec = {5,5,5,5,5,5,5};
-    REQUIRE(aare::last_smaller(vec, 5) == 0);
-}
-
-
-TEST_CASE("first_lager with vector", "[algorithm]"){
-    std::vector<double> vec = {0, 1, 2, 3, 4};
-    REQUIRE(aare::first_larger(vec, 2.5) == 3);
-}
-
-TEST_CASE("first_lager with all elements smaller returns last element", "[algorithm]"){
-    std::vector<double> vec = {0, 1, 2, 3, 4};
-    REQUIRE(aare::first_larger(vec, 50.) == 4);
-}
-
-TEST_CASE("first_lager with all elements bigger returns first element", "[algorithm]"){
-    std::vector<double> vec = {0, 1, 2, 3, 4};
-    REQUIRE(aare::first_larger(vec, -50.) == 0);
-}
-
-TEST_CASE("first_lager with all elements the same as the check returns last", "[algorithm]"){
-    std::vector<int> vec = {14, 14, 14, 14, 14};
-    REQUIRE(aare::first_larger(vec, 14) == 4);
-}
-
-TEST_CASE("first larger with the same element", "[algorithm]"){
-    std::vector<int> vec = {7,8,9,10,11};
-    REQUIRE(aare::first_larger(vec, 9) == 3);
-}
-
-TEST_CASE("cumsum works", "[algorithm]"){
-    std::vector<double> vec = {0, 1, 2, 3, 4};
-    auto result = aare::cumsum(vec);
-    REQUIRE(result.size() == vec.size());
-    REQUIRE(result[0] == 0);
-    REQUIRE(result[1] == 1);
-    REQUIRE(result[2] == 3);
-    REQUIRE(result[3] == 6);
-    REQUIRE(result[4] == 10);
-}
-TEST_CASE("cumsum works with empty vector", "[algorithm]"){
-    std::vector<double> vec = {};
-    auto result = aare::cumsum(vec);
-    REQUIRE(result.size() == 0);
-}
-TEST_CASE("cumsum works with negative numbers", "[algorithm]"){
-    std::vector<double> vec = {0, -1, -2, -3, -4};
-    auto result = aare::cumsum(vec);
-    REQUIRE(result.size() == vec.size());
-    REQUIRE(result[0] == 0);
-    REQUIRE(result[1] == -1);
-    REQUIRE(result[2] == -3);
-    REQUIRE(result[3] == -6);
-    REQUIRE(result[4] == -10);
-}
-

src/decode.cpp

@@ -1,102 +0,0 @@
-#include "aare/decode.hpp"
-#include <cmath>
-namespace aare {
-
-uint16_t adc_sar_05_decode64to16(uint64_t input){
-
-    //we want bits 29,19,28,18,31,21,27,20,24,23,25,22 and then pad to 16
-    uint16_t output = 0;
-    output |= ((input >> 22) & 1) << 11;
-    output |= ((input >> 25) & 1) << 10;
-    output |= ((input >> 23) & 1) << 9;
-    output |= ((input >> 24) & 1) << 8;
-    output |= ((input >> 20) & 1) << 7;
-    output |= ((input >> 27) & 1) << 6;
-    output |= ((input >> 21) & 1) << 5;
-    output |= ((input >> 31) & 1) << 4;
-    output |= ((input >> 18) & 1) << 3;
-    output |= ((input >> 28) & 1) << 2;
-    output |= ((input >> 19) & 1) << 1;
-    output |= ((input >> 29) & 1) << 0;
-    return output;
-}
-
-void adc_sar_05_decode64to16(NDView<uint64_t, 2> input, NDView<uint16_t,2> output){
-    if(input.shape() != output.shape()){
-        throw std::invalid_argument(LOCATION + " input and output shapes must match");
-    }
-
-    for(int64_t i = 0; i < input.shape(0); i++){
-        for(int64_t j = 0; j < input.shape(1); j++){
-            output(i,j) = adc_sar_05_decode64to16(input(i,j));
-        }
-    }
-}
-
-uint16_t adc_sar_04_decode64to16(uint64_t input){
-
-    // bit_map = array([15,17,19,21,23,4,6,8,10,12,14,16] LSB->MSB
-    uint16_t output = 0;
-    output |= ((input >> 16) & 1) << 11;
-    output |= ((input >> 14) & 1) << 10;
-    output |= ((input >> 12) & 1) << 9;
-    output |= ((input >> 10) & 1) << 8;
-    output |= ((input >> 8) & 1) << 7;
-    output |= ((input >> 6) & 1) << 6;
-    output |= ((input >> 4) & 1) << 5;
-    output |= ((input >> 23) & 1) << 4;
-    output |= ((input >> 21) & 1) << 3;
-    output |= ((input >> 19) & 1) << 2;
-    output |= ((input >> 17) & 1) << 1;
-    output |= ((input >> 15) & 1) << 0;
-    return output;
-}
-
-void adc_sar_04_decode64to16(NDView<uint64_t, 2> input, NDView<uint16_t,2> output){
-    if(input.shape() != output.shape()){
-        throw std::invalid_argument(LOCATION + " input and output shapes must match");
-    }
-    for(int64_t i = 0; i < input.shape(0); i++){
-        for(int64_t j = 0; j < input.shape(1); j++){
-            output(i,j) = adc_sar_04_decode64to16(input(i,j));
-        }
-    }
-}
-
-double apply_custom_weights(uint16_t input, const NDView<double, 1> weights) {
-    if(weights.size() > 16){
-        throw std::invalid_argument("weights size must be less than or equal to 16");
-    }
-
-    double result = 0.0;
-    for (ssize_t i = 0; i < weights.size(); ++i) {
-        result += ((input >> i) & 1) * std::pow(weights[i], i);
-    }
-    return result;
-
-}
-
-void apply_custom_weights(NDView<uint16_t, 1> input, NDView<double, 1> output, const NDView<double,1> weights) {
-    if(input.shape() != output.shape()){
-        throw std::invalid_argument(LOCATION + " input and output shapes must match");
-    }
-
-    //Calculate weights to avoid repeatedly calling std::pow
-    std::vector<double> weights_powers(weights.size());
-    for (ssize_t i = 0; i < weights.size(); ++i) {
-        weights_powers[i] = std::pow(weights[i], i);
-    }
-
-    // Apply custom weights to each element in the input array
-    for (ssize_t i = 0; i < input.shape(0); i++) {            
-        double result = 0.0;
-        for (size_t bit_index = 0; bit_index < weights_powers.size(); ++bit_index) {
-            result += ((input(i) >> bit_index) & 1) * weights_powers[bit_index];
-        }
-        output(i) = result;
-    }
-}
-
-
-
-} // namespace aare

src/decode.test.cpp

@@ -1,80 +0,0 @@
-#include "aare/decode.hpp"
-
-#include <catch2/matchers/catch_matchers_floating_point.hpp>
-#include <catch2/catch_test_macros.hpp>
-#include "aare/NDArray.hpp"
-using Catch::Matchers::WithinAbs;
-#include <vector>
-
-TEST_CASE("test_adc_sar_05_decode64to16"){
-    uint64_t input = 0;
-    uint16_t output = aare::adc_sar_05_decode64to16(input);
-    CHECK(output == 0);
-
-
-    // bit 29 on th input is bit 0 on the output
-    input = 1UL << 29;
-    output = aare::adc_sar_05_decode64to16(input);
-    CHECK(output == 1);
-
-    // test all bits by iteratting through the bitlist
-    std::vector<int> bitlist = {29, 19, 28, 18, 31, 21, 27, 20, 24, 23, 25, 22};
-    for (size_t i = 0; i < bitlist.size(); i++) {
-        input = 1UL << bitlist[i];
-        output = aare::adc_sar_05_decode64to16(input);
-        CHECK(output == (1 << i));
-    }
-
-    
-    // test a few "random" values
-    input = 0;
-    input |= (1UL << 29);
-    input |= (1UL << 19);
-    input |= (1UL << 28);
-    output = aare::adc_sar_05_decode64to16(input);
-    CHECK(output == 7UL);
-
-
-    input = 0;
-    input |= (1UL << 18);
-    input |= (1UL << 27);
-    input |= (1UL << 25);
-    output = aare::adc_sar_05_decode64to16(input);
-    CHECK(output == 1096UL);
-
-    input = 0;
-    input |= (1UL << 25);
-    input |= (1UL << 22);
-    output = aare::adc_sar_05_decode64to16(input);
-    CHECK(output == 3072UL);
- }
-
-
- TEST_CASE("test_apply_custom_weights") {
-
-    uint16_t input = 1;
-    aare::NDArray<double, 1> weights_data({3}, 0.0);
-    weights_data(0) = 1.7;
-    weights_data(1) = 2.1;
-    weights_data(2) = 1.8;
-
-    auto weights = weights_data.view();
-
-
-    double output = aare::apply_custom_weights(input, weights);
-    CHECK_THAT(output, WithinAbs(1.0, 0.001));
-
-    input = 1 << 1;
-    output = aare::apply_custom_weights(input, weights);
-    CHECK_THAT(output, WithinAbs(2.1, 0.001));
-
-
-    input = 1 << 2;
-    output = aare::apply_custom_weights(input, weights);
-    CHECK_THAT(output, WithinAbs(3.24, 0.001));
-
-    input = 0b111;
-    output = aare::apply_custom_weights(input, weights);
-    CHECK_THAT(output, WithinAbs(6.34, 0.001));
-
- }

src/geo_helpers.cpp

@@ -1,71 +0,0 @@
-
-#include "aare/geo_helpers.hpp"
-#include "fmt/core.h"
-
-namespace aare{
-
-DetectorGeometry update_geometry_with_roi(DetectorGeometry geo, aare::ROI roi) {
-    #ifdef AARE_VERBOSE
-    fmt::println("update_geometry_with_roi() called with ROI: {} {} {} {}",
-                 roi.xmin, roi.xmax, roi.ymin, roi.ymax);
-    fmt::println("Geometry: {} {} {} {} {} {}",
-                 geo.modules_x, geo.modules_y, geo.pixels_x, geo.pixels_y, geo.module_gap_row, geo.module_gap_col);
-    #endif
-    int pos_y = 0;
-    int pos_y_increment = 0;
-    for (int row = 0; row < geo.modules_y; row++) {
-        int pos_x = 0;
-        for (int col = 0; col < geo.modules_x; col++) {
-            auto &m = geo.module_pixel_0[row * geo.modules_x + col];
-            auto original_height = m.height;
-            auto original_width = m.width;
-
-            // module is to the left of the roi
-            if (m.origin_x + m.width < roi.xmin) {
-                m.width = 0;
-
-                // roi is in module
-            } else {
-                // here we only arrive when the roi is in or to the left of
-                // the module
-                if (roi.xmin > m.origin_x) {
-                    m.width -= roi.xmin - m.origin_x;
-                }
-                if (roi.xmax < m.origin_x + original_width) {
-                    m.width -= m.origin_x + original_width - roi.xmax;
-                }
-                m.origin_x = pos_x;
-                pos_x += m.width;
-            }
-
-            if (m.origin_y + m.height < roi.ymin) {
-                m.height = 0;
-            } else {
-                if ((roi.ymin > m.origin_y) && (roi.ymin < m.origin_y + m.height)) {
-                    m.height -= roi.ymin - m.origin_y;
-
-                }
-                if (roi.ymax < m.origin_y + original_height) {
-                    m.height -= m.origin_y + original_height - roi.ymax;
-                }
-                m.origin_y = pos_y;
-                pos_y_increment = m.height;
-            }
-            #ifdef AARE_VERBOSE
-    fmt::println("Module {} {} {} {}", m.origin_x, m.origin_y, m.width, m.height);
-    #endif
-        }
-        // increment pos_y
-        pos_y += pos_y_increment;
-    }
-
-    // m_rows = roi.height();
-    // m_cols = roi.width();
-    geo.pixels_x = roi.width();
-    geo.pixels_y = roi.height();
-
-    return geo;
-
-}
-
-} // namespace aare

src/geo_helpers.test.cpp

@@ -1,230 +0,0 @@
-#include "aare/File.hpp"
-#include "aare/RawMasterFile.hpp" //needed for ROI
-#include "aare/RawFile.hpp"
-
-#include <catch2/catch_test_macros.hpp>
-#include <filesystem>
-
-#include "aare/geo_helpers.hpp"
-#include "test_config.hpp"
-
-TEST_CASE("Simple ROIs on one module"){
-    // DetectorGeometry update_geometry_with_roi(DetectorGeometry geo, aare::ROI roi)
-    aare::DetectorGeometry geo;
-    
-
-    aare::ModuleGeometry mod; 
-    mod.origin_x = 0;
-    mod.origin_y = 0;
-    mod.width = 1024;
-    mod.height = 512;
-
-
-    
-    geo.pixels_x = 1024;
-    geo.pixels_y = 512;
-    geo.modules_x = 1;
-    geo.modules_y = 1;
-    geo.module_pixel_0.push_back(mod);
-
-    SECTION("ROI is the whole module"){
-        aare::ROI roi;
-        roi.xmin = 0;
-        roi.xmax = 1024;
-        roi.ymin = 0;
-        roi.ymax = 512;
-        auto updated_geo = aare::update_geometry_with_roi(geo, roi);
-
-        REQUIRE(updated_geo.pixels_x == 1024);
-        REQUIRE(updated_geo.pixels_y == 512);
-        REQUIRE(updated_geo.modules_x == 1);
-        REQUIRE(updated_geo.modules_y == 1);
-        REQUIRE(updated_geo.module_pixel_0[0].height == 512);
-        REQUIRE(updated_geo.module_pixel_0[0].width == 1024);
-    }
-    SECTION("ROI is the top left corner of the module"){
-        aare::ROI roi;
-        roi.xmin = 100;
-        roi.xmax = 200;
-        roi.ymin = 150;
-        roi.ymax = 200;
-        auto updated_geo = aare::update_geometry_with_roi(geo, roi);
-
-        REQUIRE(updated_geo.pixels_x == 100);
-        REQUIRE(updated_geo.pixels_y == 50);
-        REQUIRE(updated_geo.modules_x == 1);
-        REQUIRE(updated_geo.modules_y == 1);
-        REQUIRE(updated_geo.module_pixel_0[0].height == 50);
-        REQUIRE(updated_geo.module_pixel_0[0].width == 100);
-    }
-
-    SECTION("ROI is a small square"){
-        aare::ROI roi;
-        roi.xmin = 1000;
-        roi.xmax = 1010;
-        roi.ymin = 500;
-        roi.ymax = 510;
-        auto updated_geo = aare::update_geometry_with_roi(geo, roi);
-
-        REQUIRE(updated_geo.pixels_x == 10);
-        REQUIRE(updated_geo.pixels_y == 10);
-        REQUIRE(updated_geo.modules_x == 1);
-        REQUIRE(updated_geo.modules_y == 1);
-        REQUIRE(updated_geo.module_pixel_0[0].height == 10);
-        REQUIRE(updated_geo.module_pixel_0[0].width == 10);
-    }
-    SECTION("ROI is a few columns"){
-        aare::ROI roi;
-        roi.xmin = 750;
-        roi.xmax = 800;
-        roi.ymin = 0;
-        roi.ymax = 512;
-        auto updated_geo = aare::update_geometry_with_roi(geo, roi);
-
-        REQUIRE(updated_geo.pixels_x == 50);
-        REQUIRE(updated_geo.pixels_y == 512);
-        REQUIRE(updated_geo.modules_x == 1);
-        REQUIRE(updated_geo.modules_y == 1);
-        REQUIRE(updated_geo.module_pixel_0[0].height == 512);
-        REQUIRE(updated_geo.module_pixel_0[0].width == 50);
-    }
-}
-
-
-
-TEST_CASE("Two modules side by side"){
-    // DetectorGeometry update_geometry_with_roi(DetectorGeometry geo, aare::ROI roi)
-    aare::DetectorGeometry geo;
-    
-
-    aare::ModuleGeometry mod; 
-    mod.origin_x = 0;
-    mod.origin_y = 0;
-    mod.width = 1024;
-    mod.height = 512;
-
-    geo.pixels_x = 2048;
-    geo.pixels_y = 512;
-    geo.modules_x = 2;
-    geo.modules_y = 1;
-
-    geo.module_pixel_0.push_back(mod);
-    mod.origin_x = 1024;
-    geo.module_pixel_0.push_back(mod);
-
-    SECTION("ROI is the whole image"){
-        aare::ROI roi;
-        roi.xmin = 0;
-        roi.xmax = 2048;
-        roi.ymin = 0;
-        roi.ymax = 512;
-        auto updated_geo = aare::update_geometry_with_roi(geo, roi);
-
-        REQUIRE(updated_geo.pixels_x == 2048);
-        REQUIRE(updated_geo.pixels_y == 512);
-        REQUIRE(updated_geo.modules_x == 2);
-        REQUIRE(updated_geo.modules_y == 1);
-    }
-    SECTION("rectangle on both modules"){
-        aare::ROI roi;
-        roi.xmin = 800;
-        roi.xmax = 1300;
-        roi.ymin = 200;
-        roi.ymax = 499;
-        auto updated_geo = aare::update_geometry_with_roi(geo, roi);
-
-        REQUIRE(updated_geo.pixels_x == 500);
-        REQUIRE(updated_geo.pixels_y == 299);
-        REQUIRE(updated_geo.modules_x == 2);
-        REQUIRE(updated_geo.modules_y == 1);
-        REQUIRE(updated_geo.module_pixel_0[0].height == 299);
-        REQUIRE(updated_geo.module_pixel_0[0].width == 224);
-        REQUIRE(updated_geo.module_pixel_0[1].height == 299);
-        REQUIRE(updated_geo.module_pixel_0[1].width == 276);
-    }   
-}
-
-TEST_CASE("Three modules side by side"){
-    // DetectorGeometry update_geometry_with_roi(DetectorGeometry geo, aare::ROI roi)
-    aare::DetectorGeometry geo;
-    aare::ROI roi;
-    roi.xmin = 700;
-    roi.xmax = 2500;
-    roi.ymin = 0;
-    roi.ymax = 123;
-
-    aare::ModuleGeometry mod; 
-    mod.origin_x = 0;
-    mod.origin_y = 0;
-    mod.width = 1024;
-    mod.height = 512;
-
-    geo.pixels_x = 3072;
-    geo.pixels_y = 512;
-    geo.modules_x = 3;
-    geo.modules_y = 1;
-
-    geo.module_pixel_0.push_back(mod);
-    mod.origin_x = 1024;
-    geo.module_pixel_0.push_back(mod);
-    mod.origin_x = 2048;
-    geo.module_pixel_0.push_back(mod);
-
-    auto updated_geo = aare::update_geometry_with_roi(geo, roi);
-
-    REQUIRE(updated_geo.pixels_x == 1800);
-    REQUIRE(updated_geo.pixels_y == 123);
-    REQUIRE(updated_geo.modules_x == 3);
-    REQUIRE(updated_geo.modules_y == 1);
-    REQUIRE(updated_geo.module_pixel_0[0].height == 123);
-    REQUIRE(updated_geo.module_pixel_0[0].width == 324);
-    REQUIRE(updated_geo.module_pixel_0[1].height == 123);
-    REQUIRE(updated_geo.module_pixel_0[1].width == 1024);
-    REQUIRE(updated_geo.module_pixel_0[2].height == 123);
-    REQUIRE(updated_geo.module_pixel_0[2].width == 452);
-}
-
-TEST_CASE("Four modules as a square"){
-    // DetectorGeometry update_geometry_with_roi(DetectorGeometry geo, aare::ROI roi)
-    aare::DetectorGeometry geo;
-    aare::ROI roi;
-    roi.xmin = 500;
-    roi.xmax = 2000;
-    roi.ymin = 500;
-    roi.ymax = 600;
-
-    aare::ModuleGeometry mod; 
-    mod.origin_x = 0;
-    mod.origin_y = 0;
-    mod.width = 1024;
-    mod.height = 512;
-
-    geo.pixels_x = 2048;
-    geo.pixels_y = 1024;
-    geo.modules_x = 2;
-    geo.modules_y = 2;
-
-    geo.module_pixel_0.push_back(mod);
-    mod.origin_x = 1024;
-    geo.module_pixel_0.push_back(mod);
-    mod.origin_x = 0;
-    mod.origin_y = 512;
-    geo.module_pixel_0.push_back(mod);
-    mod.origin_x = 1024;
-    geo.module_pixel_0.push_back(mod);
-
-    auto updated_geo = aare::update_geometry_with_roi(geo, roi);
-
-    REQUIRE(updated_geo.pixels_x == 1500);
-    REQUIRE(updated_geo.pixels_y == 100);
-    REQUIRE(updated_geo.modules_x == 2);
-    REQUIRE(updated_geo.modules_y == 2);
-    REQUIRE(updated_geo.module_pixel_0[0].height == 12);
-    REQUIRE(updated_geo.module_pixel_0[0].width == 524);
-    REQUIRE(updated_geo.module_pixel_0[1].height == 12);
-    REQUIRE(updated_geo.module_pixel_0[1].width == 976);
-    REQUIRE(updated_geo.module_pixel_0[2].height == 88);
-    REQUIRE(updated_geo.module_pixel_0[2].width == 524);
-    REQUIRE(updated_geo.module_pixel_0[3].height == 88);
-    REQUIRE(updated_geo.module_pixel_0[3].width == 976);
-}

src/utils/ifstream_helpers.cpp

@@ -1,18 +0,0 @@
-#include "aare/utils/ifstream_helpers.hpp"
-
-namespace aare {
-
-std::string ifstream_error_msg(std::ifstream &ifs) {
-    std::ios_base::iostate state = ifs.rdstate();
-    if (state & std::ios_base::eofbit) {
-        return " End of file reached";
-    } else if (state & std::ios_base::badbit) {
-        return " Bad file stream";
-    } else if (state & std::ios_base::failbit) {
-        return " File read failed";
-    }else{
-        return " Unknown/no error";
-    }
-}
-
-} // namespace aare

src/utils/task.cpp

@@ -1,30 +0,0 @@
-#include "aare/utils/task.hpp"
-
-namespace aare {
-
-std::vector<std::pair<int, int>> split_task(int first, int last,
-                                            int n_threads) {
-    std::vector<std::pair<int, int>> vec;
-    vec.reserve(n_threads);
-
-    int n_frames = last - first;
-
-    if (n_threads >= n_frames) {
-        for (int i = 0; i != n_frames; ++i) {
-            vec.push_back({i, i + 1});
-        }
-        return vec;
-    }
-
-    int step = (n_frames) / n_threads;
-    for (int i = 0; i != n_threads; ++i) {
-        int start = step * i;
-        int stop = step * (i + 1);
-        if (i == n_threads - 1)
-            stop = last;
-        vec.push_back({start, stop});
-    }
-    return vec;
-}
-
-} // namespace aare

src/utils/task.test.cpp

@@ -1,32 +0,0 @@
-#include "aare/utils/task.hpp"
-
-#include <catch2/matchers/catch_matchers_floating_point.hpp>
-#include <catch2/catch_test_macros.hpp>
-
-
-TEST_CASE("Split a range into multiple tasks"){    
-
-    auto tasks = aare::split_task(0, 10, 3);
-    REQUIRE(tasks.size() == 3);
-    REQUIRE(tasks[0].first == 0);
-    REQUIRE(tasks[0].second == 3);
-    REQUIRE(tasks[1].first == 3);
-    REQUIRE(tasks[1].second == 6);
-    REQUIRE(tasks[2].first == 6);
-    REQUIRE(tasks[2].second == 10);
-
-    tasks = aare::split_task(0, 10, 1);
-    REQUIRE(tasks.size() == 1);
-    REQUIRE(tasks[0].first == 0);
-    REQUIRE(tasks[0].second == 10);
-
-    tasks = aare::split_task(0, 10, 10);
-    REQUIRE(tasks.size() == 10);
-    for (int i = 0; i < 10; i++){
-        REQUIRE(tasks[i].first == i);
-        REQUIRE(tasks[i].second == i+1);
-    }
-    
-
-
-}