Merge branch 'main' into dev/strixels/remap_simple

2026-06-04 04:48:28 +02:00 · 2026-05-22 18:12:05 +02:00
parent 69da26c3f3 41c47cb54b
commit 47ebbd2267
64 changed files with 7087 additions and 1994 deletions
@@ -1,16 +1,20 @@
-name: Build pkgs and deploy if on main
+name: Build conda pkgs

 on:
  push:
    branches:
-     - developer
+      - main
+  pull_request:
+    branches:
+      - main
+

 jobs:
  build:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-latest, ] # macos-12, windows-2019]
+        platform: [ubuntu-latest, macos-latest] 
        python-version: ["3.12",]

    runs-on: ${{ matrix.platform }}
@@ -21,10 +25,10 @@ jobs:
        shell: "bash -l {0}"

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Get conda
-        uses: conda-incubator/setup-miniconda@v3
+        uses: conda-incubator/setup-miniconda@v4
        with:
          python-version: ${{ matrix.python-version }}
          environment-file: etc/dev-env.yml
@@ -32,10 +36,9 @@ jobs:
          channels: conda-forge
          conda-remove-defaults: "true"

-  
      - name: Disable upload
        run: conda config --set anaconda_upload no

      - name: Build
-        run: conda build conda-recipe 
+        run: conda-build conda-recipe 

@@ -10,7 +10,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-latest] # macos-12, windows-2019]
+        platform: [ubuntu-latest, macos-latest] # macos-12, windows-2019]
        python-version: ["3.12",]

    runs-on: ${{ matrix.platform }}
@@ -21,10 +21,10 @@ jobs:
        shell: "bash -l {0}"

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6

      - name: Get conda
-        uses: conda-incubator/setup-miniconda@v3
+        uses: conda-incubator/setup-miniconda@v4
        with:
          python-version: ${{ matrix.python-version }}
          environment-file: etc/dev-env.yml
@@ -38,5 +38,5 @@ jobs:
      - name: Build
        env:
          CONDA_TOKEN: ${{ secrets.CONDA_TOKEN }}
-        run: conda build conda-recipe --user slsdetectorgroup --token ${CONDA_TOKEN}
+        run: conda-build conda-recipe --user slsdetectorgroup --token ${CONDA_TOKEN}

@@ -17,13 +17,13 @@ jobs:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
-        os: [ubuntu-latest,]
+        os: [ubuntu-latest,macos-latest]

    steps:
      - uses: actions/checkout@v4

      - name: Build wheels
-        run: pipx run cibuildwheel==2.23.0
+        run: pipx run cibuildwheel==3.4.0

      - uses: actions/upload-artifact@v4
        with:
@@ -0,0 +1,12 @@
+name: pre-commit
+
+on:
+  pull_request:
+
+jobs:
+  pre-commit:
+    name: pre-commit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: pre-commit/action@v3.0.1
@@ -1,25 +1,195 @@
-install/
-.cproject
-.project
-bin/
-.settings
-*.aux
-*.log
-*.out
-*.toc
+# C++ .gitignore template (https://github.com/github/gitignore/blob/main/C%2B%2B.gitignore)
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
 *.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Linker files
+*.ilk
+
+# Debugger Files
+*.pdb
+
+# Compiled Dynamic libraries
 *.so
-.*
+*.dylib
+*.dll
+*.so.*
+
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# Build directories
 build/
-RELEASE.txt
+Build/
+build-*/
+
+# CMake generated files
+CMakeFiles/
+CMakeCache.txt
+cmake_install.cmake
+Makefile
+install_manifest.txt
+compile_commands.json
+
+# Temporary files
+*.tmp
+*.log
+*.bak
+*.swp
+
+# vcpkg
+vcpkg_installed/
+
+# debug information files
+*.dwo
+
+# test output & cache
 Testing/
+.cache/

-ctbDict.cpp
-ctbDict.h
+# Python .gitignore template (https://github.com/github/gitignore/blob/main/Python.gitignore)
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class

-wheelhouse/
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
 dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST

-*.pyc
-*/__pycache__/*
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec

+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+.vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# user defined
+wheelhouse/
@@ -0,0 +1,29 @@
+fail_fast: true
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-yaml
+        exclude: conda-recipe/
+      - id: check-toml
+      - id: check-json
+      - id: mixed-line-ending
+
+  - repo: https://github.com/crate-ci/typos
+    rev: v1.45.0
+    hooks:
+      - id: typos
+        files: docs
+        args: [] # empty, to remove write-changes from the default arguments.
+
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v22.1.3
+    hooks:
+    - id: clang-format
+      name: clang-format .cpp and .hpp files
+
+  - repo: https://github.com/zultron/cmake-format-precommit
+    rev: v0.6.14
+    hooks:
+      - id: cmake-format
@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MPL-2.0
 cmake_minimum_required(VERSION 3.15)

-project(aare 
-    DESCRIPTION "Data processing library for PSI detectors"
-    HOMEPAGE_URL "https://github.com/slsdetectorgroup/aare"
-    LANGUAGES C CXX 
-)
+project(
+  aare
+  DESCRIPTION "Data processing library for PSI detectors"
+  HOMEPAGE_URL "https://github.com/slsdetectorgroup/aare"
+  LANGUAGES C CXX)

 # Read VERSION file into project version
 set(VERSION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/VERSION")
@@ -13,37 +13,34 @@ file(READ "${VERSION_FILE}" VERSION_CONTENT)
 string(STRIP "${VERSION_CONTENT}" PROJECT_VERSION_STRING)
 set(PROJECT_VERSION ${PROJECT_VERSION_STRING})

-set(CMAKE_CXX_STANDARD 17) 
+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
-        )
+  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
+if(${CMAKE_VERSION} VERSION_GREATER "3.24")
+  cmake_policy(SET CMP0135 NEW) # Fetch content download timestamp
 endif()
 cmake_policy(SET CMP0079 NEW)

 include(GNUInstallDirs)
 include(FetchContent)

-#Set default build type if none was specified
+# Set default build type if none was specified
 include(cmake/helpers.cmake)

-
 default_build_type("Release")
 set_std_fs_lib()
 message(STATUS "Extra linking to fs lib:${STD_FS_LIB}")

 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})

-
 # General options
 option(AARE_PYTHON_BINDINGS "Build python bindings" OFF)
 option(AARE_TESTS "Build tests" OFF)
@@ -53,7 +50,10 @@ option(AARE_IN_GITHUB_ACTIONS "Running in Github Actions" OFF)
 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_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
@@ -63,154 +63,201 @@ 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)
+option(AARE_FETCH_MINUIT2 "Use FetchContent to download Minuit2" ON)

-
-#Convenience option to use system libraries only (no FetchContent)
+# Convenience option to use system libraries only (no FetchContent)
 option(AARE_SYSTEM_LIBRARIES "Use system libraries" OFF)
 if(AARE_SYSTEM_LIBRARIES)
-    message(STATUS "Build using system libraries")
-    set(AARE_FETCH_FMT OFF CACHE BOOL "Disabled FetchContent for FMT" FORCE)
-    set(AARE_FETCH_PYBIND11 OFF CACHE BOOL "Disabled FetchContent for pybind11" FORCE)
-    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
+  message(STATUS "Build using system libraries")
+  set(AARE_FETCH_FMT
+      OFF
+      CACHE BOOL "Disabled FetchContent for FMT" FORCE)
+  set(AARE_FETCH_PYBIND11
+      OFF
+      CACHE BOOL "Disabled FetchContent for pybind11" FORCE)
+  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 and Minuit2 when setting AARE_SYSTEM_LIBRARIES since these
+  # are not available on conda-forge
 endif()

 if(AARE_BENCHMARKS)
-    add_subdirectory(benchmarks)
+  add_subdirectory(benchmarks)
 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)
+  # 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
-        )
+  # 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()

-    #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)
+  set_property(TARGET lmfit PROPERTY POSITION_INDEPENDENT_CODE ON)
 else()
-    find_package(lmfit REQUIRED)
+  find_package(lmfit REQUIRED)
 endif()

+if(AARE_FETCH_MINUIT2)
+  # Patch minuit2 to avoid messing with cmake policies
+  set(MINUIT2_PATCH_COMMAND git apply
+                            ${CMAKE_CURRENT_SOURCE_DIR}/patches/minuit2.patch)
+  FetchContent_Declare(
+    Minuit2
+    GIT_REPOSITORY https://github.com/GooFit/Minuit2.git
+    GIT_TAG master
+    PATCH_COMMAND ${MINUIT2_PATCH_COMMAND}
+    UPDATE_DISCONNECTED 1)
+  # Disable Minuit2 extras we don't need
+  set(minuit2_mpi
+      OFF
+      CACHE BOOL "")
+  set(minuit2_omp
+      OFF
+      CACHE BOOL "")
+  set(BUILD_TESTING
+      OFF
+      CACHE BOOL "")
+  set(MINUIT2_INSTALL
+      ON
+      CACHE BOOL "")
+  FetchContent_MakeAvailable(Minuit2)
+
+  set_property(TARGET Minuit2Math PROPERTY POSITION_INDEPENDENT_CODE ON)
+  set_property(TARGET Minuit2 PROPERTY POSITION_INDEPENDENT_CODE ON)
+else()
+  find_package(Minuit2 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")
-    set(BUILD_SHARED OFF CACHE BOOL "Switch off libzmq shared libs")
-    set(WITH_PERF_TOOL OFF CACHE BOOL "")
-    set(ENABLE_CPACK OFF CACHE BOOL "")
-    set(ENABLE_CLANG OFF CACHE BOOL "")
-    set(ENABLE_CURVE OFF CACHE BOOL "")
-    set(ENABLE_DRAFTS OFF CACHE BOOL "")
+  # 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")
+  set(BUILD_SHARED
+      OFF
+      CACHE BOOL "Switch off libzmq shared libs")
+  set(WITH_PERF_TOOL
+      OFF
+      CACHE BOOL "")
+  set(ENABLE_CPACK
+      OFF
+      CACHE BOOL "")
+  set(ENABLE_CLANG
+      OFF
+      CACHE BOOL "")
+  set(ENABLE_CURVE
+      OFF
+      CACHE BOOL "")
+  set(ENABLE_DRAFTS
+      OFF
+      CACHE BOOL "")

-    # TODO! Verify that this is what we want to do in aare
-    # Using GetProperties and Populate to be able to exclude zmq
-    # from install (not possible with FetchContent_MakeAvailable(libzmq))
-    FetchContent_GetProperties(libzmq)
-    if(NOT libzmq_POPULATED)
-        FetchContent_Populate(libzmq)
-        add_subdirectory(${libzmq_SOURCE_DIR} ${libzmq_BINARY_DIR} EXCLUDE_FROM_ALL)
-    endif()
+  # TODO! Verify that this is what we want to do in aare Using GetProperties and
+  # Populate to be able to exclude zmq from install (not possible with
+  # FetchContent_MakeAvailable(libzmq))
+  FetchContent_GetProperties(libzmq)
+  if(NOT libzmq_POPULATED)
+    FetchContent_Populate(libzmq)
+    add_subdirectory(${libzmq_SOURCE_DIR} ${libzmq_BINARY_DIR} EXCLUDE_FROM_ALL)
+  endif()
 else()
-    find_package(ZeroMQ 4 REQUIRED)
+  find_package(ZeroMQ 4 REQUIRED)
 endif()

-
-if (AARE_FETCH_FMT)
-    set(FMT_TEST OFF CACHE INTERNAL "disabling fmt tests")
-    FetchContent_Declare(
-            fmt
-            GIT_REPOSITORY  https://github.com/fmtlib/fmt.git
-            GIT_TAG         10.2.1
-            GIT_PROGRESS    TRUE
-            USES_TERMINAL_DOWNLOAD TRUE
-    )
-    set(FMT_INSTALL ON CACHE BOOL "")
-    # set(FMT_CMAKE_DIR "")
-    FetchContent_MakeAvailable(fmt)
-    set_property(TARGET fmt PROPERTY POSITION_INDEPENDENT_CODE ON)
-    install(TARGETS fmt 
-        EXPORT ${project}-targets
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}   
-    )  
+if(AARE_FETCH_FMT)
+  set(FMT_TEST
+      OFF
+      CACHE INTERNAL "disabling fmt tests")
+  FetchContent_Declare(
+    fmt
+    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
+    GIT_TAG 12.1.0
+    GIT_PROGRESS TRUE
+    USES_TERMINAL_DOWNLOAD TRUE)
+  set(FMT_INSTALL
+      ON
+      CACHE BOOL "")
+  FetchContent_MakeAvailable(fmt)
+  set_property(TARGET fmt PROPERTY POSITION_INDEPENDENT_CODE ON)
 else()
-      find_package(fmt 6 REQUIRED)
+  find_package(fmt 6 REQUIRED)
 endif()

-
-if (AARE_FETCH_JSON)
-    FetchContent_Declare(
-        json 
-        URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz
-    )
-    set(JSON_Install ON CACHE BOOL "")
-    FetchContent_MakeAvailable(json)
-    set(NLOHMANN_JSON_TARGET_NAME nlohmann_json)
-    
-    install(
-        TARGETS nlohmann_json
-        EXPORT "${TARGETS_EXPORT_NAME}"
-    )
-    message(STATUS "target: ${NLOHMANN_JSON_TARGET_NAME}")
+if(AARE_FETCH_JSON)
+  FetchContent_Declare(
+    json
+    URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz)
+  set(JSON_Install
+      ON
+      CACHE BOOL "")
+  FetchContent_MakeAvailable(json)
 else()
-    find_package(nlohmann_json 3.11.3 REQUIRED)
+  find_package(nlohmann_json 3.11.3 REQUIRED)
 endif()

 include(GNUInstallDirs)
@@ -224,7 +271,6 @@ endif()
 string(TOUPPER "${PROJECT_NAME}" PROJECT_NAME_UPPER)
 string(TOLOWER "${PROJECT_NAME}" PROJECT_NAME_LOWER)

-
 # Set targets export name (used by slsDetectorPackage and dependencies)
 set(TARGETS_EXPORT_NAME "${PROJECT_NAME_LOWER}-targets")
 set(namespace "aare::")
@@ -233,107 +279,86 @@ set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})

 # Check if project is being used directly or via add_subdirectory
 set(AARE_MASTER_PROJECT OFF)
-if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-    set(AARE_MASTER_PROJECT ON)
+if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+  set(AARE_MASTER_PROJECT ON)
 endif()

 add_library(aare_compiler_flags INTERFACE)
 target_compile_features(aare_compiler_flags INTERFACE cxx_std_17)

-
-
-#################
+# ##############################################################################
 # MSVC specific #
-#################
+# ##############################################################################
 if(MSVC)
-add_compile_definitions(AARE_MSVC)
-if(CMAKE_BUILD_TYPE STREQUAL "Release")
+  add_compile_definitions(AARE_MSVC)
+  if(CMAKE_BUILD_TYPE STREQUAL "Release")
    message(STATUS "Release build")
    target_compile_options(aare_compiler_flags INTERFACE /O2)
-else()
+  else()
    message(STATUS "Debug build")
-    target_compile_options(
-        aare_compiler_flags 
-        INTERFACE 
-            /Od 
-            /Zi 
-            /MDd
-            /D_ITERATOR_DEBUG_LEVEL=2
-    )
-    target_link_options(
-        aare_compiler_flags
-        INTERFACE
-            /DEBUG:FULL
-            )
-endif()
-target_compile_options(
-    aare_compiler_flags 
-    INTERFACE
-    /w # disable warnings
-)
-
+    target_compile_options(aare_compiler_flags
+                           INTERFACE /Od /Zi /MDd /D_ITERATOR_DEBUG_LEVEL=2)
+    target_link_options(aare_compiler_flags INTERFACE /DEBUG:FULL)
+  endif()
+  target_compile_options(aare_compiler_flags INTERFACE /w # disable warnings
+  )

 else()
-######################
-# GCC/Clang specific #
-######################
+  # ############################################################################
+  # GCC/Clang specific #
+  # ############################################################################

-if(CMAKE_BUILD_TYPE STREQUAL "Release")
+  if(CMAKE_BUILD_TYPE STREQUAL "Release")
    message(STATUS "Release build")
    target_compile_options(aare_compiler_flags INTERFACE -O3)
-else()
+  else()
    message(STATUS "Debug build")
-endif()
+  endif()

-# Common flags for GCC and Clang
-target_compile_options(
-    aare_compiler_flags 
-    INTERFACE 
-        -Wall 
-        -Wextra 
-        -pedantic 
-        -Wshadow 
-        -Wold-style-cast
-        -Wnon-virtual-dtor
-        -Woverloaded-virtual
-        -Wdouble-promotion
-        -Wformat=2
-        -Wredundant-decls
-        -Wvla
-        -Wdouble-promotion
-        -Werror=return-type #important can cause segfault in optimzed builds
-    )
+  # Common flags for GCC and Clang
+  target_compile_options(
+    aare_compiler_flags
+    INTERFACE -Wall
+              -Wextra
+              -pedantic
+              -Wshadow
+              -Wold-style-cast
+              -Wnon-virtual-dtor
+              -Woverloaded-virtual
+              -Wdouble-promotion
+              -Wformat=2
+              -Wredundant-decls
+              -Wvla
+              -Wdouble-promotion
+              -Werror=return-type # important can cause segfault in optimzed
+                                  # builds
+  )

-endif() #GCC/Clang specific
+endif() # GCC/Clang specific

 if(AARE_PYTHON_BINDINGS)
-    add_subdirectory(python)
+  add_subdirectory(python)
 endif()

 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
-    )
+  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()

 if(AARE_TESTS)
-    enable_testing()
-    add_subdirectory(tests)
-    target_compile_definitions(tests PRIVATE AARE_TESTS)
+  enable_testing()
+  add_subdirectory(tests)
+  target_compile_definitions(tests PRIVATE AARE_TESTS)
 endif()

-###------------------------------------------------------------------------------MAIN LIBRARY
-###------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------MAIN
+# LIBRARY
+# ------------------------------------------------------------------------------------------

 set(PUBLICHEADERS
    include/aare/ArrayExpr.hpp
@@ -348,6 +373,9 @@ set(PUBLICHEADERS
    include/aare/Dtype.hpp
    include/aare/File.hpp
    include/aare/Fit.hpp
+    include/aare/Chi2.hpp
+    include/aare/FitModel.hpp
+    include/aare/Models.hpp
    include/aare/FileInterface.hpp
    include/aare/FilePtr.hpp
    include/aare/Frame.hpp
@@ -372,9 +400,7 @@ set(PUBLICHEADERS
    include/aare/RawMasterFile.hpp
    include/aare/RawSubFile.hpp
    include/aare/VarClusterFinder.hpp
-    include/aare/utils/task.hpp
-)
-
+    include/aare/utils/task.hpp)

 set(SourceFiles
    ${CMAKE_CURRENT_SOURCE_DIR}/src/calibration.cpp
@@ -400,148 +426,150 @@ set(SourceFiles
    ${CMAKE_CURRENT_SOURCE_DIR}/src/RemapFormat.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/src/to_string.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/task.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/ifstream_helpers.cpp
-) 
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/ifstream_helpers.cpp)

 add_library(aare_core STATIC ${SourceFiles})
-target_include_directories(aare_core PUBLIC 
-    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>" 
-    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>" 
-)
+target_include_directories(
+  aare_core PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+                   "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")

 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)

 target_link_libraries(
-    aare_core 
-    PUBLIC 
-    fmt::fmt 
-    nlohmann_json::nlohmann_json 
-    ${STD_FS_LIB} # from helpers.cmake
-    PRIVATE 
-    aare_compiler_flags 
-    Threads::Threads
-    $<BUILD_INTERFACE:lmfit>
+  aare_core
+  PUBLIC fmt::fmt nlohmann_json::nlohmann_json ${STD_FS_LIB} # from
+                                                             # helpers.cmake
+         Minuit2::Minuit2
+  PRIVATE aare_compiler_flags Threads::Threads $<BUILD_INTERFACE:lmfit>)

-)
+target_include_directories(
+  aare_core SYSTEM
+  PRIVATE $<TARGET_PROPERTY:Minuit2::Minuit2,INTERFACE_INCLUDE_DIRECTORIES>)

 set_property(TARGET aare_core PROPERTY POSITION_INDEPENDENT_CODE ON)

 if(AARE_TESTS)
-    target_compile_definitions(aare_core PRIVATE AARE_TESTS)
+  target_compile_definitions(aare_core PRIVATE AARE_TESTS)
 endif()
 if(AARE_VERBOSE)
-    target_compile_definitions(aare_core PUBLIC AARE_VERBOSE)
-    target_compile_definitions(aare_core PUBLIC AARE_LOG_LEVEL=aare::logDEBUG5)
+  target_compile_definitions(aare_core PUBLIC AARE_VERBOSE)
+  target_compile_definitions(aare_core PUBLIC AARE_LOG_LEVEL=aare::logDEBUG5)
 else()
-    target_compile_definitions(aare_core PUBLIC AARE_LOG_LEVEL=aare::logERROR)
+  target_compile_definitions(aare_core PUBLIC AARE_LOG_LEVEL=aare::logERROR)
 endif()

 if(AARE_CUSTOM_ASSERT)
-    target_compile_definitions(aare_core PUBLIC AARE_CUSTOM_ASSERT)
+  target_compile_definitions(aare_core PUBLIC AARE_CUSTOM_ASSERT)
 endif()

-set_target_properties(aare_core PROPERTIES
-    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
-    PUBLIC_HEADER "${PUBLICHEADERS}"
-)
+set_target_properties(
+  aare_core PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
+                       PUBLIC_HEADER "${PUBLICHEADERS}")

 if(AARE_TESTS)
-    set(TestSources
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/algorithm.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/calibration.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/DetectorGeometry.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/Interpolation.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/Cluster.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/CalculateEta.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/ClusterFile.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/ClusterFinderMT.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/RawSubFile.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/task.test.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/src/to_string.test.cpp
-
-        )
-    target_sources(tests PRIVATE ${TestSources} )
+  set(TestSources
+      ${CMAKE_CURRENT_SOURCE_DIR}/src/algorithm.test.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/src/calibration.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/DetectorGeometry.test.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/src/Interpolation.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/Cluster.test.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/src/CalculateEta.test.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/src/ClusterFile.test.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/src/ClusterFinderMT.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/RawSubFile.test.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/task.test.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/src/to_string.test.cpp)
+  target_sources(tests PRIVATE ${TestSources})
 endif()

-
 if(AARE_MASTER_PROJECT)
-    install(TARGETS aare_core aare_compiler_flags 
-        EXPORT "${TARGETS_EXPORT_NAME}"
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/aare
-    )
+  install(
+    TARGETS aare_core aare_compiler_flags
+    EXPORT "${TARGETS_EXPORT_NAME}"
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/aare)
 endif()

 set(CMAKE_INSTALL_RPATH $ORIGIN)
 set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)

-
-# #Overall target to link to when using the library
-# add_library(aare INTERFACE) 
+# #Overall target to link to when using the library add_library(aare INTERFACE)
 # target_link_libraries(aare INTERFACE aare_core aare_compiler_flags)
-# target_include_directories(aare INTERFACE 
-#     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-#     $<INSTALL_INTERFACE:include>
-# )
+# target_include_directories(aare INTERFACE
+# $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+# $<INSTALL_INTERFACE:include> )

 # add_subdirectory(examples)

 if(AARE_DOCS)
-    add_subdirectory(docs)
+  add_subdirectory(docs)
 endif()

-
 # custom target to run check formatting with clang-format
 add_custom_target(
-    check-format
-    COMMAND find \( -name "*.cpp" -o -name "*.hpp" \) -not -path "./build/*" | xargs -I {} -n 1 -P 10 bash -c  "clang-format -Werror -style=\"file:.clang-format\" {} | diff {} -"
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    COMMENT "Checking code formatting with clang-format"
-    VERBATIM
-    
-)
+  check-format
+  COMMAND
+    find \\ (-name "*.cpp" -o -name "*.hpp" \\) -not -path "./build/*" | xargs
+    -I {} -n 1 -P 10 bash -c
+    "clang-format -Werror -style=\"file:.clang-format\" {} | diff {} -"
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  COMMENT "Checking code formatting with clang-format"
+  VERBATIM)

 add_custom_target(
-    format-files
-    COMMAND find \( -name "*.cpp" -o -name "*.hpp" \) -not -path "./build/*" | xargs -I {} -n 1 -P 10 bash -c "clang-format -i -style=\"file:.clang-format\" {}"
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    COMMENT "Formatting with clang-format"
-    VERBATIM
-)
+  format-files
+  COMMAND
+    find \\ (-name "*.cpp" -o -name "*.hpp" \\) -not -path "./build/*" | xargs
+    -I {} -n 1 -P 10 bash -c "clang-format -i -style=\"file:.clang-format\" {}"
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  COMMENT "Formatting with clang-format"
+  VERBATIM)

-if (AARE_IN_GITHUB_ACTIONS)
-    message(STATUS "Running in Github Actions")
-    set(CLANG_TIDY_COMMAND "clang-tidy-17")
+if(AARE_IN_GITHUB_ACTIONS)
+  message(STATUS "Running in Github Actions")
+  set(CLANG_TIDY_COMMAND "clang-tidy-17")
 else()
-    set(CLANG_TIDY_COMMAND "clang-tidy")
+  set(CLANG_TIDY_COMMAND "clang-tidy")
 endif()

 add_custom_target(
-    clang-tidy
-    COMMAND find \( -path "./src/*" -a -not -path "./src/python/*" -a \( -name "*.cpp"   -not -name "*.test.cpp" \)  \)    -not -name "CircularFifo.hpp" -not -name "ProducerConsumerQueue.hpp" -not -name "VariableSizeClusterFinder.hpp" | xargs -I {} -n 1 -P 10 bash -c "${CLANG_TIDY_COMMAND} --config-file=.clang-tidy -p build {}"
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    COMMENT "linting with clang-tidy"
-    VERBATIM
-)
+  clang-tidy
+  COMMAND
+    find \\ (-path
+             "./src/*"
+             -a
+             -not
+             -path
+             "./src/python/*"
+             -a
+             \\
+             (-name "*.cpp" -not -name "*.test.cpp" \\)
+             \\) -not -name "CircularFifo.hpp" -not -name
+    "ProducerConsumerQueue.hpp" -not -name "VariableSizeClusterFinder.hpp" |
+    xargs -I {} -n 1 -P 10 bash -c
+    "${CLANG_TIDY_COMMAND} --config-file=.clang-tidy -p build {}"
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  COMMENT "linting with clang-tidy"
+  VERBATIM)

 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)
+  set(CMAKE_INSTALL_DIR "share/cmake/${PROJECT_NAME}")
+  set(PROJECT_LIBRARIES aare-core aare-compiler-flags)
+  include(cmake/package_config.cmake)
 endif()
@@ -79,4 +79,15 @@ make install

 ```bash
 conda build . --variants="{python: [3.11, 3.12, 3.13]}"
-```
+```
+
+## Developer's guide
+
+We are looking forward to your contributions via pull requests!
+
+If you want to fix an existing bug or propose a new feature:
+
+1. Install `pre-commit` python package and setup it `pre-commit install`
+2. Create a new branch with `git branch branch_name`
+3. Implement your changes and make a commit (`pre-commit` will check your code automatically)
+4. Push your commit and open a pull request if needed
@@ -1,5 +1,21 @@
 # Release notes

+## HEAD 
+
+
+### New Features:
+
+- Added a new Minuit2-based fitting framework for ``Gaussian``, ``RisingScurve``, ``FallingScurve``, ``Pol1`` and ``Pol2`` models.
+- setter and getter for nSigma for ClusterFinder ``aare.ClusterFinder().nSigma = 2``, ``aare.ClusterFinderMT().set_nSigma(2)`` 
+- mask opeartor for ClusterVector ``masked_clustervector = aare.ClusterVector()(mask)``
+- passing pre computed eta values to ``aare.Interpolator.interpolate`` alongside clusters
+
+### Bugfixes:
+
+- Fixed ``split_task(first, last, n_threads)`` so task ranges now correctly respect the ``first`` offset. Previously, non-zero starting indices could generate incorrect subranges.
+
+
+
 ## 2026.3.17

 ### New Features:
@@ -2,27 +2,39 @@

 include(FetchContent)

-
 FetchContent_Declare(
-    benchmark
-    GIT_REPOSITORY https://github.com/google/benchmark.git
-    GIT_TAG        v1.8.3 # Change to the latest version if needed
+  benchmark
+  GIT_REPOSITORY https://github.com/google/benchmark.git
+  GIT_TAG v1.8.3 # Change to the latest version if needed
 )

 # Ensure Google Benchmark is built correctly
-set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "" FORCE)
+set(BENCHMARK_ENABLE_TESTING
+    OFF
+    CACHE BOOL "" FORCE)

 FetchContent_MakeAvailable(benchmark)

 add_executable(benchmarks)

-target_sources(benchmarks PRIVATE ndarray_benchmark.cpp calculateeta_benchmark.cpp reduce_benchmark.cpp)
+target_sources(
+  benchmarks PRIVATE ndarray_benchmark.cpp calculateeta_benchmark.cpp
+                     reduce_benchmark.cpp)

 # Link Google Benchmark and other necessary libraries
-target_link_libraries(benchmarks PRIVATE benchmark::benchmark aare_core aare_compiler_flags)
+target_link_libraries(benchmarks PRIVATE benchmark::benchmark aare_core
+                                         aare_compiler_flags)

 # Set output properties
-set_target_properties(benchmarks PROPERTIES
-    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
-    OUTPUT_NAME run_benchmarks
-)
+set_target_properties(
+  benchmarks PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
+                        OUTPUT_NAME run_benchmarks)
+
+add_executable(fit_benchmark fit_benchmark.cpp)
+target_link_libraries(fit_benchmark PRIVATE benchmark::benchmark aare_core
+                                            aare_compiler_flags)
+target_include_directories(
+  fit_benchmark SYSTEM
+  PRIVATE $<TARGET_PROPERTY:Minuit2::Minuit2,INTERFACE_INCLUDE_DIRECTORIES>)
+set_target_properties(fit_benchmark PROPERTIES RUNTIME_OUTPUT_DIRECTORY
+                                               ${CMAKE_BINARY_DIR})
@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: MPL-2.0
+#include "aare/Chi2.hpp"
+#include "aare/Fit.hpp"
+#include "aare/FitModel.hpp"
+#include "aare/Models.hpp"
+
+#include <benchmark/benchmark.h>
+#include <cmath>
+#include <random>
+#include <string>
+#include <vector>
+
+struct TestCase {
+    std::string name;
+    double true_A;
+    double true_mu;
+    double true_sig;
+    double noise_frac;
+};
+
+static const std::vector<TestCase> &get_test_cases() {
+    static const std::vector<TestCase> cases = {
+        {"Clean_signal", 1000.0, 50.0, 5.0, 0.02},
+        {"Moderate_noise", 1000.0, 50.0, 5.0, 0.10},
+        {"High_noise", 1000.0, 50.0, 5.0, 0.30},
+        {"Narrow_peak", 500.0, 25.0, 1.0, 0.05},
+        {"Wide_peak", 200.0, 100.0, 20.0, 0.05},
+        {"Off_center_peak", 800.0, -15.0, 3.0, 0.05},
+    };
+    return cases;
+}
+
+// ----------------------------------------------------------------
+// Synthetic data generation (deterministic per test case)
+// ----------------------------------------------------------------
+static constexpr ssize_t N_POINTS = 100;
+static constexpr unsigned SEED = 42;
+
+struct GeneratedData {
+    aare::NDArray<double, 1> x;
+    aare::NDArray<double, 1> y;
+    aare::NDArray<double, 1> y_err;
+
+    GeneratedData() : x({N_POINTS}), y({N_POINTS}), y_err({N_POINTS}) {}
+};
+
+static GeneratedData generate_gaussian_data(const TestCase &tc) {
+    GeneratedData d;
+
+    double x_min = tc.true_mu - 5.0 * tc.true_sig;
+    double x_max = tc.true_mu + 5.0 * tc.true_sig;
+    double dx = (x_max - x_min) / (N_POINTS - 1);
+
+    std::mt19937 rng(SEED);
+    double noise_sigma = tc.noise_frac * tc.true_A;
+    std::normal_distribution<double> noise(0.0, noise_sigma);
+
+    for (ssize_t i = 0; i < N_POINTS; ++i) {
+        d.x[i] = x_min + i * dx;
+        double clean = tc.true_A * std::exp(-std::pow(d.x[i] - tc.true_mu, 2) /
+                                            (2.0 * std::pow(tc.true_sig, 2)));
+        d.y[i] = clean + noise(rng);
+        d.y_err[i] = noise_sigma;
+    }
+    return d;
+}
+
+static void report_accuracy(benchmark::State &state, const TestCase &tc,
+                            const aare::NDArray<double, 1> &result) {
+    state.counters["dA"] = result(0) - tc.true_A;
+    state.counters["dMu"] = result(1) - tc.true_mu;
+    state.counters["dSig"] = result(2) - tc.true_sig;
+}
+
+// ----------
+// Benchmarks
+// ----------
+
+// 1. lmcurve
+static void BM_FitGausLm(benchmark::State &state) {
+    const auto &tc = get_test_cases()[state.range(0)];
+    auto data = generate_gaussian_data(tc);
+    auto xv = data.x.view();
+    auto yv = data.y.view();
+
+    aare::NDArray<double, 1> result;
+    for (auto _ : state) {
+        result = aare::fit_gaus(xv, yv);
+        benchmark::DoNotOptimize(result.data());
+    }
+
+    report_accuracy(state, tc, result);
+    state.SetLabel(tc.name);
+}
+
+// 2. Minuit2, analytic gradient (no Hesse)
+static void BM_FitGausMinuitGrad(benchmark::State &state) {
+    const auto &tc = get_test_cases()[state.range(0)];
+    auto data = generate_gaussian_data(tc);
+    auto xv = data.x.view();
+    auto yv = data.y.view();
+
+    const auto model = aare::FitModel<aare::model::Gaussian>(
+        /*strategy = */ 0,
+        /*max_calls = */ 500, // increase for noisy signals
+        /*tolerance = */ 0.5,
+        /*compute_errors = */ false);
+
+    aare::NDArray<double, 1> result;
+    for (auto _ : state) {
+        result =
+            aare::fit_pixel<aare::model::Gaussian, aare::func::Chi2Gaussian>(
+                model, xv, yv);
+        benchmark::DoNotOptimize(result.data());
+    }
+
+    report_accuracy(state, tc, result);
+    state.SetLabel(tc.name);
+}
+
+// 3. Minuit2, analytic gradient + Hesse
+static void BM_FitGausMinuitGradHesse(benchmark::State &state) {
+    const auto &tc = get_test_cases()[state.range(0)];
+    auto data = generate_gaussian_data(tc);
+    auto xv = data.x.view();
+    auto yv = data.y.view();
+    auto ev = data.y_err.view();
+
+    const auto model = aare::FitModel<aare::model::Gaussian>(
+        0, 500, 0.5, true); // compute_errors = true -> Runs Hesse and provides
+                            // errors on fitted params
+
+    aare::NDArray<double, 1> result;
+    for (auto _ : state) {
+        result =
+            aare::fit_pixel<aare::model::Gaussian, aare::func::Chi2Gaussian>(
+                model, xv, yv, ev);
+        benchmark::DoNotOptimize(result.data());
+    }
+
+    // result has 6 elements: [A, mu, sig, err_A, err_mu, err_sig]
+    report_accuracy(state, tc, result);
+
+    // Also report Hesse uncertainties
+    if (result.size() >= 6) {
+        state.counters["errA"] = result(3);
+        state.counters["errMu"] = result(4);
+        state.counters["errSig"] = result(5);
+    }
+    state.SetLabel(tc.name);
+}
+
+BENCHMARK(BM_FitGausLm)->DenseRange(0, 5)->Unit(benchmark::kMicrosecond);
+
+BENCHMARK(BM_FitGausMinuitGrad)
+    ->DenseRange(0, 5)
+    ->Unit(benchmark::kMicrosecond);
+
+BENCHMARK(BM_FitGausMinuitGradHesse)
+    ->DenseRange(0, 5)
+    ->Unit(benchmark::kMicrosecond);
+
+BENCHMARK_MAIN();
@@ -1,11 +1,11 @@
-#Look for an executable called sphinx-build
-find_program(SPHINX_EXECUTABLE
-             NAMES sphinx-build sphinx-build-3.6
-             DOC "Path to sphinx-build executable")
- 
+# Look for an executable called sphinx-build
+find_program(
+  SPHINX_EXECUTABLE
+  NAMES sphinx-build sphinx-build-3.6
+  DOC "Path to sphinx-build executable")
+
 include(FindPackageHandleStandardArgs)
- 
-#Handle standard arguments to find_package like REQUIRED and QUIET
-find_package_handle_standard_args(Sphinx
-                                  "Failed to find sphinx-build executable"
-                                  SPHINX_EXECUTABLE)
+
+# Handle standard arguments to find_package like REQUIRED and QUIET
+find_package_handle_standard_args(
+  Sphinx "Failed to find sphinx-build executable" SPHINX_EXECUTABLE)
@@ -1,46 +1,53 @@
 function(default_build_type val)
-if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-  message(STATUS "No build type selected, default to Release")
-  set(CMAKE_BUILD_TYPE ${val} CACHE STRING "Build type (default ${val})" FORCE)
-endif()
+  if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    message(STATUS "No build type selected, default to Release")
+    set(CMAKE_BUILD_TYPE
+        ${val}
+        CACHE STRING "Build type (default ${val})" FORCE)
+  endif()
 endfunction()

 function(set_std_fs_lib)
-# from pybind11
-# Check if we need to add -lstdc++fs or -lc++fs or nothing
-if(DEFINED CMAKE_CXX_STANDARD AND CMAKE_CXX_STANDARD LESS 17)
-  set(STD_FS_NO_LIB_NEEDED TRUE)
-elseif(MSVC)
-  set(STD_FS_NO_LIB_NEEDED TRUE)
-else()
-  file(
-    WRITE ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
-    "#include <filesystem>\nint main(int argc, char ** argv) {\n  std::filesystem::path p(argv[0]);\n  return p.string().length();\n}"
-  )
-  try_compile(
-    STD_FS_NO_LIB_NEEDED ${CMAKE_CURRENT_BINARY_DIR}
-    SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
-    COMPILE_DEFINITIONS -std=c++17)
-  try_compile(
-    STD_FS_NEEDS_STDCXXFS ${CMAKE_CURRENT_BINARY_DIR}
-    SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
-    COMPILE_DEFINITIONS -std=c++17
-    LINK_LIBRARIES stdc++fs)
-  try_compile(
-    STD_FS_NEEDS_CXXFS ${CMAKE_CURRENT_BINARY_DIR}
-    SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
-    COMPILE_DEFINITIONS -std=c++17
-    LINK_LIBRARIES c++fs)
-endif()
+  # from pybind11 Check if we need to add -lstdc++fs or -lc++fs or nothing
+  if(DEFINED CMAKE_CXX_STANDARD AND CMAKE_CXX_STANDARD LESS 17)
+    set(STD_FS_NO_LIB_NEEDED TRUE)
+  elseif(MSVC)
+    set(STD_FS_NO_LIB_NEEDED TRUE)
+  else()
+    file(
+      WRITE ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+      "#include <filesystem>\nint main(int argc, char ** argv) {\n  std::filesystem::path p(argv[0]);\n  return p.string().length();\n}"
+    )
+    try_compile(
+      STD_FS_NO_LIB_NEEDED ${CMAKE_CURRENT_BINARY_DIR}
+      SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+      COMPILE_DEFINITIONS -std=c++17)
+    try_compile(
+      STD_FS_NEEDS_STDCXXFS ${CMAKE_CURRENT_BINARY_DIR}
+      SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+      COMPILE_DEFINITIONS -std=c++17
+      LINK_LIBRARIES stdc++fs)
+    try_compile(
+      STD_FS_NEEDS_CXXFS ${CMAKE_CURRENT_BINARY_DIR}
+      SOURCES ${CMAKE_CURRENT_BINARY_DIR}/main.cpp
+      COMPILE_DEFINITIONS -std=c++17
+      LINK_LIBRARIES c++fs)
+  endif()

-if(${STD_FS_NEEDS_STDCXXFS})
-  set(STD_FS_LIB stdc++fs PARENT_SCOPE)
-elseif(${STD_FS_NEEDS_CXXFS})
-  set(STD_FS_LIB c++fs PARENT_SCOPE)
-elseif(${STD_FS_NO_LIB_NEEDED})
-  set(STD_FS_LIB "" PARENT_SCOPE)
-else()
-  message(WARNING "Unknown C++17 compiler - not passing -lstdc++fs")
-  set(STD_FS_LIB "")
-endif()
-endfunction()
+  if(${STD_FS_NEEDS_STDCXXFS})
+    set(STD_FS_LIB
+        stdc++fs
+        PARENT_SCOPE)
+  elseif(${STD_FS_NEEDS_CXXFS})
+    set(STD_FS_LIB
+        c++fs
+        PARENT_SCOPE)
+  elseif(${STD_FS_NO_LIB_NEEDED})
+    set(STD_FS_LIB
+        ""
+        PARENT_SCOPE)
+  else()
+    message(WARNING "Unknown C++17 compiler - not passing -lstdc++fs")
+    set(STD_FS_LIB "")
+  endif()
+endfunction()
@@ -15,21 +15,17 @@ configure_package_config_file(
 write_basic_package_version_file(
  "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWER}-config-version.cmake"
  VERSION ${PROJECT_VERSION}
-  COMPATIBILITY SameMajorVersion
-)
+  COMPATIBILITY SameMajorVersion)

-install(FILES
-  "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWER}-config.cmake"
-  "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWER}-config-version.cmake"
+install(
+  FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWER}-config.cmake"
+        "${PROJECT_BINARY_DIR}/${PROJECT_NAME_LOWER}-config-version.cmake"
  COMPONENT devel
-  DESTINATION ${CMAKE_INSTALL_DIR}
-)
+  DESTINATION ${CMAKE_INSTALL_DIR})

-
-if (PROJECT_LIBRARIES OR PROJECT_STATIC_LIBRARIES)
+if(PROJECT_LIBRARIES OR PROJECT_STATIC_LIBRARIES)
  install(
    EXPORT "${TARGETS_EXPORT_NAME}"
    FILE ${PROJECT_NAME_LOWER}-targets.cmake
-    DESTINATION ${CMAKE_INSTALL_DIR}
-    )
-endif ()
+    DESTINATION ${CMAKE_INSTALL_DIR})
+endif()
@@ -5,12 +5,16 @@ python:

 c_compiler:
  - gcc                        # [linux]
+  - clang                      # [osx]

 c_stdlib:
  - sysroot                    # [linux]
+  - macosx_deployment_target   # [osx]

 cxx_compiler:
  - gxx                        # [linux]
+  - clangxx                    # [osx]

-c_stdlib_version:              # [linux]
+c_stdlib_version:              
  - 2.17                       # [linux]
+  - "11.0"                     # [osx]
@@ -25,9 +25,9 @@ requirements:
  host:
    - python
    - pip
-    - numpy=2.1
+    - numpy >=2.1
    - scikit-build-core
-    - pybind11 >=2.13.0
+    - pybind11 >=3.0.3
    - matplotlib # needed in host to solve the environment for run

  run:
@@ -42,6 +42,7 @@ test:
    - aare
  requires:
    - pytest
+    - pytest_check
    - boost-histogram 
  source_files:
    - python/tests
@@ -2,53 +2,41 @@
 find_package(Doxygen REQUIRED)
 find_package(Sphinx REQUIRED)

-#Doxygen
+# Doxygen
 set(DOXYGEN_IN ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in)
 set(DOXYGEN_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
 configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT} @ONLY)

-#Sphinx
+# Sphinx
 set(SPHINX_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/src)
 set(SPHINX_BUILD ${CMAKE_CURRENT_BINARY_DIR})

-
-file(GLOB_RECURSE SPHINX_SOURCE_FILES
-     CONFIGURE_DEPENDS
-     RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/src"
-     "${CMAKE_CURRENT_SOURCE_DIR}/src/*.rst"
-)
+file(
+  GLOB_RECURSE SPHINX_SOURCE_FILES CONFIGURE_DEPENDS
+  RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/src"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/*.rst")

 foreach(relpath IN LISTS SPHINX_SOURCE_FILES)
-    set(src  "${CMAKE_CURRENT_SOURCE_DIR}/src/${relpath}")
-    set(dst  "${SPHINX_BUILD}/src/${relpath}")
+  set(src "${CMAKE_CURRENT_SOURCE_DIR}/src/${relpath}")
+  set(dst "${SPHINX_BUILD}/src/${relpath}")

-    message(STATUS "Copying ${src} to ${dst}")
-    configure_file("${src}" "${dst}" COPYONLY)
+  message(STATUS "Copying ${src} to ${dst}")
+  configure_file("${src}" "${dst}" COPYONLY)
 endforeach()

-configure_file(
-    "${CMAKE_CURRENT_SOURCE_DIR}/conf.py.in"
-    "${SPHINX_BUILD}/conf.py"
-    @ONLY
-)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/conf.py.in"
+               "${SPHINX_BUILD}/conf.py" @ONLY)

-file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/figures"
-     DESTINATION "${SPHINX_BUILD}") 
+file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/figures" DESTINATION "${SPHINX_BUILD}")

-configure_file(
-    "${CMAKE_CURRENT_SOURCE_DIR}/static/extra.css"
-    "${SPHINX_BUILD}/static/css/extra.css"
-    @ONLY
-)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/static/extra.css"
+               "${SPHINX_BUILD}/static/css/extra.css" @ONLY)

 add_custom_target(
-    docs
-    COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
-    COMMAND ${SPHINX_EXECUTABLE} -a -b html
-    -Dbreathe_projects.aare=${CMAKE_CURRENT_BINARY_DIR}/xml
-    -c "${SPHINX_BUILD}"
-    ${SPHINX_BUILD}/src 
-    ${SPHINX_BUILD}/html
-    COMMENT "Generating documentation with Sphinx"
-)
-
+  docs
+  COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
+  COMMAND
+    ${SPHINX_EXECUTABLE} -a -b html
+    -Dbreathe_projects.aare=${CMAKE_CURRENT_BINARY_DIR}/xml -c "${SPHINX_BUILD}"
+    ${SPHINX_BUILD}/src ${SPHINX_BUILD}/html
+  COMMENT "Generating documentation with Sphinx")
@@ -70,7 +70,7 @@ Supported are the following :math:`\eta`-functions:
 The :math:`\eta` values can range between 0,1. Note they only range between 0,1 because the position of the center pixel (red) can change. 
 If the center pixel is in the bottom left pixel :math:`\eta_x` will be close to zero. If the center pixel is in the bottom right pixel :math:`\eta_y` will be close to 1.

-One can apply this :math:`\eta` not only on 2x2 clusters but on clusters with any size. Then the 2x2 subcluster with maximum energy is choosen and the :math:`\eta` function applied on the subcluster.
+One can apply this :math:`\eta` not only on 2x2 clusters but on clusters with any size. Then the 2x2 subcluster with maximum energy is chosen and the :math:`\eta` function applied on the subcluster.

 .. doxygenfunction:: aare::calculate_eta2(const ClusterVector<ClusterType>&)

@@ -150,7 +150,7 @@ Interpolation class:
    Make sure to use the same :math:`\eta`-function during interpolation as given by the joint :math:`\eta`-distribution passed to the constructor. 

 .. Note:: 
-    Make sure to use resonable energy bins, when constructing the joint distribution. If data is too sparse for a given energy the interpolation will lead to erreneous results.
+    Make sure to use reasonable energy bins, when constructing the joint distribution. If data is too sparse for a given energy the interpolation will lead to erroneous results.

 .. doxygenclass:: aare::Interpolator
   :members:
@@ -12,7 +12,7 @@ The structure of the file is:
 * ...

 There is no metadata indicating number of frames or the size of the image, but this
-will be infered by this reader. 
+will be inferred by this reader. 

 .. doxygenstruct:: aare::JungfrauDataHeader
   :members:
@@ -38,7 +38,7 @@ C++ functions that support the ClusterVector or to view it as a numpy array.
 Below is the API of the ClusterVector_Cluster3x3i but all variants share the same API.

 .. autoclass::  aare._aare.ClusterVector_Cluster3x3i
-    :special-members: __init__
+    :special-members: __init__, __call__ 
    :members:
    :undoc-members:
    :show-inheritance:
@@ -111,7 +111,7 @@ Interpolation class for :math:`\eta`-Interpolation
   The interpolation might lead to erroneous photon positions for clusters at the boarders of a frame. Make sure to filter out such cases.

 .. Note:: 
-    Make sure to use resonable energy bins, when constructing the joint distribution. If data is too sparse for a given energy the interpolation will lead to erreneous results.
+    Make sure to use reasonable energy bins, when constructing the joint distribution. If data is too sparse for a given energy the interpolation will lead to erreneous results.


 .. py:currentmodule:: aare
@@ -5,12 +5,12 @@ dependencies:
  - anaconda-client
  - catch2
  - conda-build
-  - doxygen 
+  - doxygen
  - sphinx
-  - breathe 
-  - sphinx_rtd_theme 
-  - furo 
-  - zeromq 
+  - breathe
+  - sphinx_rtd_theme
+  - furo
+  - zeromq
  - pybind11
  - numpy
  - matplotlib
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: MPL-2.0
+#pragma once
+#include "aare/Models.hpp"
+#include "aare/NDView.hpp"
+#include <Minuit2/FCNGradientBase.h>
+#include <algorithm>
+#include <cmath>
+#include <stdexcept>
+#include <vector>
+
+namespace aare {
+
+namespace func {
+
+/**
+ * @brief Generic chi-squared FCN with analytic gradient for a 1D model.
+ *
+ * @tparam Model  A model struct that satisfies:
+ *   - static constexpr std::size_t npar;
+ *   - static double eval(double x, const std::vector<double>& par);
+ *   - static void eval_and_grad(double x, const std::vector<double>& par,
+ *                                double& f, std::array<double, npar>& g);
+ *   - static bool is_valid(const std::vector<double>& par);
+ *
+ * Gradient:
+ *   d(chi2)/dp_k = -2 * sum_i  w_i * (y_i - f_i) * df_i/dp_k
+ *
+ *   where w_i = 1/sigma_i^2 (weighted) or 1 (unweighted).
+ *
+ * By providing analytic gradients we avoid 2*npar extra function evaluations
+ * per Minuit step that would otherwise be spent on finite differences.
+ *
+ * @throws std::invalid_argument if par.size() != Model::npar.
+ *
+ * Invalid model parameters do not throw; they return a large penalty
+ * (and a zero gradient fallback) so the minimizer can remain in control.
+ */
+template <class Model>
+class Chi2Model1DGrad : public ROOT::Minuit2::FCNGradientBase {
+  public:
+    Chi2Model1DGrad(NDView<double, 1> x, NDView<double, 1> y)
+        : x_(x), y_(y), s_(), weighted_(false) {}
+
+    Chi2Model1DGrad(NDView<double, 1> x, NDView<double, 1> y,
+                    NDView<double, 1> y_err)
+        : x_(x), y_(y), s_(y_err), weighted_(true) {}
+
+    ~Chi2Model1DGrad() override = default;
+
+    double operator()(const std::vector<double> &par) const override {
+        if (par.size() != Model::npar) {
+            throw std::invalid_argument(
+                "Chi2Model1DGrad: wrong parameter vector size.");
+        }
+
+        if (!Model::is_valid(par))
+            return 1e20;
+
+        double chi2 = 0.0;
+
+        if (weighted_) {
+            for (ssize_t i = 0; i < x_.size(); ++i) {
+                const double si = s_[i];
+                if (si == 0.0)
+                    continue;
+
+                const double f_i = Model::eval(x_[i], par);
+                const double r_i = y_[i] - f_i;
+                chi2 += (r_i * r_i) / (si * si);
+            }
+        } else {
+            for (ssize_t i = 0; i < x_.size(); ++i) {
+                const double f_i = Model::eval(x_[i], par);
+                const double r_i = y_[i] - f_i;
+                chi2 += r_i * r_i;
+            }
+        }
+
+        return chi2;
+    }
+
+    std::vector<double>
+    Gradient(const std::vector<double> &par) const override {
+        if (par.size() != Model::npar) {
+            throw std::invalid_argument(
+                "Chi2Model1DGrad: wrong parameter vector size.");
+        }
+
+        std::vector<double> grad(Model::npar, 0.0);
+        if (!Model::is_valid(par))
+            return grad;
+
+        std::array<double, Model::npar> df{};
+        double f_i = 0.0;
+
+        if (weighted_) {
+            for (ssize_t i = 0; i < x_.size(); ++i) {
+                const double si = s_[i];
+                if (si == 0.0)
+                    continue;
+
+                Model::eval_and_grad(x_[i], par, f_i, df);
+
+                const double r_i = y_[i] - f_i;
+                const double c = -2.0 * r_i / (si * si);
+
+                for (std::size_t k = 0; k < Model::npar; ++k) {
+                    grad[k] += c * df[k];
+                }
+            }
+        } else {
+            for (ssize_t i = 0; i < x_.size(); ++i) {
+                Model::eval_and_grad(x_[i], par, f_i, df);
+
+                const double r_i = y_[i] - f_i;
+                const double c = -2.0 * r_i;
+
+                for (std::size_t k = 0; k < Model::npar; ++k) {
+                    grad[k] += c * df[k];
+                }
+            }
+        }
+
+        return grad;
+    }
+
+    /** @brief Error definition: 1.0 for chi-squared (delta_chi2 = 1 ->
+     * 1-sigma). */
+    double Up() const override { return 1.0; }
+
+  private:
+    NDView<double, 1> x_;
+    NDView<double, 1> y_;
+    NDView<double, 1> s_;
+    bool weighted_;
+};
+
+// ── Convenient aliases ──────────────────────────────────────────────
+
+using Chi2Gaussian = Chi2Model1DGrad<aare::model::Gaussian>;
+using Chi2GaussianErfcPlateau =
+    Chi2Model1DGrad<aare::model::GaussianErfcPlateau>;
+using Chi2GaussianChargeSharing =
+    Chi2Model1DGrad<aare::model::GaussianChargeSharing>;
+using Chi2GaussianChargeSharingKb =
+    Chi2Model1DGrad<aare::model::GaussianChargeSharingKb>;
+using Chi2RisingScurve = Chi2Model1DGrad<aare::model::RisingScurve>;
+using Chi2FallingScurve = Chi2Model1DGrad<aare::model::FallingScurve>;
+using Chi2Pol1 = Chi2Model1DGrad<aare::model::Pol1>;
+using Chi2Pol2 = Chi2Model1DGrad<aare::model::Pol2>;
+
+} // namespace func
+
+} // namespace aare
@@ -17,7 +17,7 @@ template <class ItemType> class CircularFifo {
    aare::ProducerConsumerQueue<ItemType> filled_slots;

  public:
-    CircularFifo() : CircularFifo(100){};
+    CircularFifo() : CircularFifo(100) {};
    CircularFifo(uint32_t size)
        : fifo_size(size), free_slots(size + 1), filled_slots(size + 1) {

@@ -383,7 +383,7 @@ ClusterFile<ClusterType, Enable>::read_frame_without_cut() {
            "Unexpected error (not feof or ferror) when reading frame number");
    }

-    int32_t n_clusters; // Saved as 32bit integer in the cluster file
+    uint32_t n_clusters;
    if (fread(&n_clusters, sizeof(n_clusters), 1, fp) != 1) {
        throw std::runtime_error(LOCATION +
                                 "Could not read number of clusters");
@@ -23,7 +23,7 @@ template <typename ClusterType = Cluster<int32_t, 3, 3>,
          typename = std::enable_if_t<no_2x2_cluster<ClusterType>::value>>
 class ClusterFinder {
    Shape<2> m_image_size;
-    const PEDESTAL_TYPE m_nSigma;
+    PEDESTAL_TYPE m_nSigma;
    const PEDESTAL_TYPE c2;
    const PEDESTAL_TYPE c3;
    Pedestal<PEDESTAL_TYPE> m_pedestal;
@@ -53,6 +53,10 @@ class ClusterFinder {
                      << ", nSigma: " << nSigma << ", capacity: " << capacity;
    }

+    void set_nSigma(PEDESTAL_TYPE nSigma) { m_nSigma = nSigma; }
+
+    PEDESTAL_TYPE get_nSigma() const { return m_nSigma; }
+
    void push_pedestal_frame(NDView<FRAME_TYPE, 2> frame) {
        m_pedestal.push(frame);
    }
@@ -284,6 +284,23 @@ class ClusterFinderMT {
    //     auto rc = m_input_queue.write(std::move(frame));
    //     fmt::print("pushed frame {}\n", rc);
    // }
+
+    /**
+     * @brief Set the nSigma value for all the cluster finders.
+     * @param nSigma number of sigma above the pedestal to consider a photon
+     * during cluster finding.
+     */
+    void set_nSigma(const PEDESTAL_TYPE nSigma) {
+        // Wait for all queues to be empty before changing the sigma
+        for (auto &q : m_input_queues) {
+            while (!q->isEmpty()) {
+                std::this_thread::sleep_for(m_default_wait);
+            }
+        }
+        for (auto &cf : m_cluster_finders) {
+            cf->set_nSigma(nSigma);
+        }
+    }
 };

 } // namespace aare
@@ -59,6 +59,27 @@ class ClusterVector<Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>> {
        other.m_data.clear();
    }

+    /**
+     * @brief Create a copy of the clustervector by filtering clusters in the
+     * ClusterVector using a boolean mask.
+     * @param mask boolean 1d mask
+     * @return ClusterVector containing only the clusters where the mask is
+     * true
+     */
+    ClusterVector operator()(NDView<bool, 1> mask) {
+        if (static_cast<size_t>(mask.size()) != m_data.size()) {
+            throw std::runtime_error(
+                LOCATION + "Mask size does not match number of clusters");
+        }
+        ClusterVector result(capacity(), frame_number());
+        for (size_t i = 0; i < m_data.size(); ++i) {
+            if (mask(i)) {
+                result.push_back(m_data[i]);
+            }
+        }
+        return result;
+    }
+
    // Move assignment operator
    ClusterVector &operator=(ClusterVector &&other) noexcept {
        if (this != &other) {
@@ -5,7 +5,17 @@
 #include <fmt/core.h>
 #include <vector>

+#include "aare/Chi2.hpp"
+#include "aare/FitModel.hpp"
 #include "aare/NDArray.hpp"
+#include "aare/utils/par.hpp"
+#include "aare/utils/task.hpp"
+
+#include "Minuit2/FunctionMinimum.h"
+#include "Minuit2/MnHesse.h"
+#include "Minuit2/MnMigrad.h"
+#include "Minuit2/MnPrint.h"
+#include "Minuit2/MnUserParameters.h"

 namespace aare {

@@ -24,20 +34,6 @@ NDArray<double, 1> scurve2(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);
-
-std::array<double, 6> scurve_init_par(const NDView<double, 1> x,
-                                      const NDView<double, 1> y);
-std::array<double, 6> scurve2_init_par(const NDView<double, 1> x,
-                                       const NDView<double, 1> y);
-
 static constexpr int DEFAULT_NUM_THREADS = 4;

 /**
@@ -118,4 +114,223 @@ void fit_scurve2(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);
+
+// Minuit2 fit_pixel / fit_3d object based API
+
+// _____________________________________________________________________
+//
+// fit_pixel — single-pixel minimisation
+// _____________________________________________________________________
+
+/**
+ * @brief Fit a single pixel's data using Minuit2.
+ *
+ * The caller provides a thread-local clone of MnUserParameters so that
+ * no heap allocation happens here (only SetValue/SetError stores).
+ *
+ * User-precedence rules:
+ *   - Fixed parameters: untouched (value and fixed flag preserved from clone).
+ *   - User-set start:   value preserved, step size auto-filled.
+ *   - Neither:          both value and step size auto-filled from data.
+ *
+ * @tparam Model  Model struct (Gaussian, RisingScurve, …).
+ * @tparam FCN    Chi2 functor type (Chi2Model1D or Chi2Model1DGrad
+ * instantiation).
+ *
+ * @param model       The FitModel configuration (read-only).
+ * @param upar_local  Thread-local clone of model.upar().  Modified in place.
+ * @param x           Scan points (shared across all pixels).
+ * @param y           Measured values for this pixel.
+ * @param y_err       Per-point uncertainties (empty view -> unweighted fit).
+ *
+ * @return NDArray<double,1> of size:
+ *   - compute_errors: [p0..pN, err0..errN, chi2]  -> 2*npar + 1
+ *   - otherwise:      [p0..pN, chi2]              -> npar + 1
+ */
+template <typename Model, typename FCN>
+NDArray<double, 1> fit_pixel(const FitModel<Model> &model,
+                             ROOT::Minuit2::MnUserParameters &upar_local,
+                             NDView<double, 1> x, NDView<double, 1> y,
+                             NDView<double, 1> y_err) {
+
+    constexpr std::size_t npar = Model::npar;
+    const bool want_errors = model.compute_errors();
+    const ssize_t result_size = want_errors ? (2 * npar + 1) : (npar + 1);
+
+    // ──── automatic parameter estimation ─────────────
+    auto start = Model::estimate_par(x, y);
+
+    // dead / degenerate pixel guard
+    if (!Model::is_valid(std::vector<double>(start.begin(), start.end()))) {
+        return NDArray<double, 1>({result_size}, 0.0);
+    }
+
+    // ──── data-range statistics for step sizes ─────────────
+    double x_range, y_range, slope_scale;
+    model::compute_ranges(x, y, x_range, y_range, slope_scale);
+
+    std::array<double, npar> steps{};
+    Model::compute_steps(start, x_range, y_range, slope_scale, steps);
+
+    // ── apply auto-estimates respecting user precedence ─────────────
+    for (std::size_t i = 0; i < npar; ++i) {
+        // fixed: do not touch at all
+        if (model.is_user_fixed(i)) {
+            continue;
+        }
+
+        if (!model.is_user_start(i)) {
+            upar_local.SetValue(i, start[i]);
+        }
+
+        upar_local.SetError(i, steps[i]);
+    }
+
+    // ──── build functor ────────
+    auto chi2 = (y_err.size() > 0) ? FCN(x, y, y_err) : FCN(x, y);
+
+    // ──── run minimizer ────────
+    ROOT::Minuit2::MnMigrad migrad(chi2, upar_local, model.strategy());
+    ROOT::Minuit2::FunctionMinimum min =
+        migrad(model.max_calls(), model.tolerance());
+
+    if (!min.IsValid())
+        return NDArray<double, 1>({result_size}, 0.0);
+
+    // ──── pack results ────────
+    if (want_errors) {
+        ROOT::Minuit2::MnHesse hesse;
+        hesse(chi2, min);
+
+        const auto &values = min.UserState().Params();
+        const auto &errors = min.UserState().Errors();
+
+        NDArray<double, 1> result({result_size});
+        for (std::size_t k = 0; k < npar; ++k) {
+            result[k] = values[k];
+            result[npar + k] = errors[k];
+        }
+        result[2 * npar] = min.Fval();
+        return result;
+    }
+
+    const auto &values = min.UserState().Params();
+    NDArray<double, 1> result({result_size});
+    for (std::size_t k = 0; k < npar; ++k)
+        result[k] = values[k];
+    result[npar] = min.Fval();
+    return result;
+}
+
+// ── self-contained for 1D / standalone use ─────────
+template <typename Model, typename FCN>
+NDArray<double, 1> fit_pixel(const FitModel<Model> &model, NDView<double, 1> x,
+                             NDView<double, 1> y, NDView<double, 1> y_err) {
+    auto upar_local = model.upar();
+    return fit_pixel<Model, FCN>(model, upar_local, x, y, y_err);
+}
+
+// Overload: uncertainties not provided
+template <typename Model, typename FCN>
+NDArray<double, 1> fit_pixel(const FitModel<Model> &model, NDView<double, 1> x,
+                             NDView<double, 1> y) {
+    auto upar_local = model.upar();
+    return fit_pixel<Model, FCN>(model, upar_local, x, y, NDView<double, 1>{});
+}
+
+// _____________________________________________________________________
+//
+// fit_3d — row-parallel fitting over (rows, cols) pixel grid
+// _____________________________________________________________________
+/**
+ * @brief Fit all pixels in a 3D data cube (rows x cols x n_scan).
+ *
+ * @tparam Model  Model struct.
+ * @tparam FCN    Chi2 functor type.
+ *
+ * @param model      Fit configuration shared by all pixels.
+ * @param x          Scan points, shape `(n_scan)`.
+ * @param y          Measured values, shape `(rows, cols, n_scan)`.
+ * @param y_err      Uncertainties, same shape as y, or empty for unweighted
+ * fits.
+ * @param par_out    Output parameters, shape `(rows, cols, npar)`.
+ * @param err_out    Output parameter errors, shape `(rows, cols, npar)`, if
+ * used.
+ * @param chi2_out   Output chi-squared / objective values, shape `(rows,
+ * cols)`.
+ * @param n_threads  Number of threads used to split rows.
+ *
+ */
+template <typename Model, typename FCN>
+void fit_3d(
+    const FitModel<Model> &model, NDView<double, 1> x, // (n_scan)
+    NDView<double, 3> y,                               // (rows, cols, n_scan)
+    NDView<double, 3> y_err, // (rows, cols, n_scan) or empty for unweighted fit
+    NDView<double, 3> par_out, NDView<double, 3> err_out,
+    NDView<double, 2> chi2_out, int n_threads) {
+    const std::size_t npar = Model::npar;
+
+    // ──── checks ───────
+    if (x.size() != y.shape(2))
+        throw std::runtime_error("fit_3d: x.size() must match y.shape(2).");
+
+    if (par_out.shape(0) != y.shape(0) || par_out.shape(1) != y.shape(1) ||
+        par_out.shape(2) != npar)
+        throw std::runtime_error("par_out must have shape [rows, cols, npar].");
+
+    if (chi2_out.shape(0) != y.shape(0) || chi2_out.shape(1) != y.shape(1))
+        throw std::runtime_error("chi2_out must have shape [rows, cols].");
+
+    const bool has_errors = (y_err.size() > 0);
+    const bool want_par_errors = (err_out.size() > 0) && model.compute_errors();
+
+    if (has_errors) {
+        if (y.shape(0) != y_err.shape(0) || y.shape(1) != y_err.shape(1) ||
+            y.shape(2) != y_err.shape(2))
+            throw std::runtime_error(
+                "fit_3d: y and y_err must have identical shape.");
+
+        if (err_out.shape(0) != y.shape(0) || err_out.shape(1) != y.shape(1) ||
+            err_out.shape(2) != npar)
+            throw std::runtime_error(
+                "err_out must have shape [rows, cols, npar].");
+    }
+
+    // ──── parallel dispatch ───────
+    auto process = [&](ssize_t first_row, ssize_t last_row) {
+        // one clone per thread
+        auto upar_local = model.upar();
+
+        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)});
+                NDView<double, 1> errors =
+                    has_errors ? NDView<double, 1>(&y_err(row, col, 0),
+                                                   {y_err.shape(2)})
+                               : NDView<double, 1>{};
+
+                auto res =
+                    fit_pixel<Model, FCN>(model, upar_local, x, values, errors);
+
+                for (std::size_t k = 0; k < npar; ++k) {
+                    par_out(row, col, k) = res(k);
+                }
+
+                if (want_par_errors) {
+                    for (std::size_t k = 0; k < npar; ++k) {
+                        err_out(row, col, k) = res(npar + k);
+                    }
+                    chi2_out(row, col) = res(2 * npar);
+                } else {
+                    chi2_out(row, col) = res(npar);
+                }
+            }
+        }
+    };
+
+    auto tasks = split_task(0, static_cast<int>(y.shape(0)), n_threads);
+    RunInParallel(process, tasks);
+}
+
 } // namespace aare
@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: MPL-2.0
+#pragma once
+
+#include "aare/Models.hpp"
+#include <type_traits>
+
+#include "Minuit2/MnStrategy.h"
+#include "Minuit2/MnUserParameters.h"
+
+namespace aare {
+
+template <typename Model> class FitModel {
+    ROOT::Minuit2::MnUserParameters upar_;
+    ROOT::Minuit2::MnStrategy strategy_;
+    unsigned int max_calls_;
+    double tolerance_;
+    bool compute_errors_;
+
+    std::array<bool, Model::npar> user_fixed_{};
+    std::array<bool, Model::npar> user_start_{};
+
+    /** @brief Safely resolve a parameter name to its index. */
+    unsigned int checked_index(const std::string &name) const {
+        for (std::size_t i = 0; i < npar; ++i) {
+            if (upar_.Name(i) == name)
+                return static_cast<unsigned int>(i);
+        }
+        throw std::runtime_error("FitModel: unknown parameter name '" + name +
+                                 "'");
+    }
+
+  public:
+    static constexpr std::size_t npar = Model::npar;
+
+    /**
+     * @brief Construct a fit model with sensible defaults.
+     *
+     * @param strategy        Minuit2 strategy level (0 = fast/gradient, 1 =
+     * default).
+     * @param max_calls       Maximum FCN calls per pixel minimisation.
+     * @param tolerance       Minuit2 EDM tolerance.
+     * @param compute_errors  If true, run MnHesse after minimisation.
+     */
+    FitModel(unsigned int strategy = 0, unsigned int max_calls = 100,
+             double tolerance = 0.5, bool compute_errors = false)
+        : strategy_(strategy), max_calls_(max_calls), tolerance_(tolerance),
+          compute_errors_(compute_errors) {
+        for (std::size_t i = 0; i < npar; ++i) {
+            const auto pi = Model::param_info[i];
+            const bool has_lo = std::isfinite(pi.default_lo);
+            const bool has_hi = std::isfinite(pi.default_hi);
+
+            // Add parameters and valid bounds
+            if (has_lo && has_hi) {
+                upar_.Add(pi.name, 0.0, 1.0, pi.default_lo, pi.default_hi);
+            } else if (has_lo) {
+                upar_.Add(pi.name, 0.0, 1.0, pi.default_lo, 1e6);
+            } else {
+                upar_.Add(pi.name, 0.0, 1.0);
+            }
+        }
+    }
+
+    /** @brief Set lower and upper bounds for parameter idx.*/
+    void SetParLimits(unsigned int idx, double lo, double hi) {
+        upar_.SetLimits(idx, lo, hi);
+    }
+
+    /**
+     * @brief Fix parameter idx at value val.
+     *
+     * Excluded from minimisation.  Automatic estimates will not touch it.
+     */
+    void FixParameter(unsigned int idx, double val) {
+        SetParameter(idx, val);
+        upar_.Fix(idx);
+        user_fixed_[idx] = true;
+    }
+
+    /** @brief Release a previously fixed parameter, re-enabling auto estimates.
+     */
+    void ReleaseParameter(unsigned int idx) {
+        upar_.Release(idx);
+        user_fixed_[idx] = false;
+    }
+
+    void ReleaseParameter(const std::string &name) {
+        ReleaseParameter(checked_index(name));
+    }
+
+    /** @brief Set an explicit starting value for parameter idx.*/
+    void SetParameter(unsigned int idx, double val) {
+        upar_.SetValue(idx, val);
+        user_start_[idx] = true;
+    }
+
+    void SetParameter(const std::string &name, double val) {
+        // go through index to maintain user_start_ bookkeeping
+        SetParameter(checked_index(name), val);
+    }
+
+    void FixParameter(const std::string &name, double val) {
+        // go through index to maintain user_fixed_ bookkeeping
+        FixParameter(checked_index(name), val);
+    }
+
+    void SetParLimits(const std::string &name, double lo, double hi) {
+        SetParLimits(checked_index(name), lo, hi);
+    }
+
+    std::string GetParName(unsigned int idx) const {
+        return upar_.GetName(idx);
+    }
+
+    std::vector<std::string> GetParNames() const {
+        std::vector<std::string> names;
+        for (std::size_t i = 0; i < npar; ++i)
+            names.push_back(GetParName(i));
+        return names;
+    }
+    static constexpr std::size_t GetNpar() noexcept { return npar; }
+
+    void SetMaxCalls(unsigned int n) { max_calls_ = n; }
+    void SetTolerance(double t) { tolerance_ = t; }
+    void SetComputeErrors(bool b) { compute_errors_ = b; }
+
+    // accessors
+    const ROOT::Minuit2::MnUserParameters &upar() const { return upar_; }
+    const ROOT::Minuit2::MnStrategy &strategy() const { return strategy_; }
+    unsigned int max_calls() const { return max_calls_; }
+    double tolerance() const { return tolerance_; }
+    bool compute_errors() const { return compute_errors_; }
+    bool is_user_fixed(unsigned int idx) const { return user_fixed_[idx]; }
+    bool is_user_start(unsigned int idx) const { return user_start_[idx]; }
+};
+
+} // namespace aare
@@ -93,6 +93,26 @@ class Interpolator {
    std::vector<Photon>
    interpolate(const ClusterVector<ClusterType> &clusters) const;

+    /**
+     * @brief interpolates the cluster centers for all clusters to a better
+     * precision
+     * @param clusters clusters of photon hits to interpolate
+     * @param etas precomputed eta values for each cluster (must be in the same
+     * order as the clusters)
+     * @return interpolated photons (photon positions are given as double but
+     * following row column format e.g. x=0, y=0 means top row and first column
+     * of frame) (An interpolated photon position of (1.5, 2.5) corresponds to
+     * an estimated photon hit at the pixel center of pixel (1,2))
+     */
+    template <typename T, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
+              typename CoordType = uint16_t,
+              typename Enable = std::enable_if_t<is_cluster_v<
+                  Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>>>>
+    std::vector<Photon> interpolate(
+        const ClusterVector<Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>>
+            &clusters,
+        const std::vector<Eta2<T>> &etas) const;
+
    /**
     * @brief transforms the eta values to uniform coordinates based on the CDF
     * ieta_x and ieta_y
@@ -171,11 +191,14 @@ Coordinate2D Interpolator::transform_eta_values(const Eta2<T> &eta) const {

    if (static_cast<ssize_t>(ix) >= m_etabinsx.size() - 1 ||
        static_cast<ssize_t>(iy) >= m_etabinsy.size() - 1 ||
-        static_cast<ssize_t>(ie) >= m_energy_bins.size() - 1)
-        throw std::runtime_error(
-            fmt::format("Eta values out of bounds of eta distribution: eta.x = "
-                        "{:.4f}, eta.y = {:.4f}, energy = {:.4f}",
-                        eta.x, eta.y, eta.sum));
+        static_cast<ssize_t>(ie) >= m_energy_bins.size() - 1) {
+        throw std::runtime_error(fmt::format(
+            "Eta values (eta.x = {:4f}, eta.y = {:4f}, energy = {}) out of "
+            "bounds of eta distribution with largest values: (eta.x = {:4f}, "
+            "eta.y = {:4f}, energy = {:4f})",
+            eta.x, eta.y, eta.sum, *(m_etabinsx.end() - 1),
+            *(m_etabinsy.end() - 1), *(m_energy_bins.end() - 1)));
+    }

    // TODO: bilinear interpolation only works if all bins have a size > 1 -
    // otherwise bilinear interpolation with zero values which skew the
@@ -203,16 +226,16 @@ Interpolator::interpolate(const ClusterVector<ClusterType> &clusters) const {
        photon.y = cluster.y;
        photon.energy = static_cast<decltype(photon.energy)>(eta.sum);

+        Coordinate2D uniform_coordinates{};
+
        try {
            // check if eta values are within bounds
-            transform_eta_values(eta);
+            uniform_coordinates = transform_eta_values(eta);
        } catch (const std::runtime_error &e) {
            throw std::runtime_error(
                fmt::format("{} for cluster: {}", e.what(), cluster_index));
        }

-        auto uniform_coordinates = transform_eta_values(eta);
-
        if (EtaFunction == &calculate_eta2<typename ClusterType::value_type,
                                           ClusterType::cluster_size_x,
                                           ClusterType::cluster_size_y,
@@ -262,4 +285,48 @@ Interpolator::interpolate(const ClusterVector<ClusterType> &clusters) const {
    return photons;
 }

+template <typename T, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
+          typename CoordType, typename Enable>
+std::vector<Photon> Interpolator::interpolate(
+    const ClusterVector<Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>>
+        &clusters,
+    const std::vector<Eta2<T>> &etas) const {
+
+    if (clusters.size() != etas.size()) {
+        throw std::runtime_error(
+            fmt::format("Size of clusters and precomputed etas must be the "
+                        "same, but got {} clusters and {} etas",
+                        clusters.size(), etas.size()));
+    }
+
+    std::vector<Photon> photons;
+    photons.reserve(clusters.size());
+
+    for (size_t i = 0; i < clusters.size(); ++i) {
+        const auto &cluster = clusters[i];
+        const auto &eta = etas[i];
+
+        Photon photon;
+        photon.x = cluster.x;
+        photon.y = cluster.y;
+        photon.energy = static_cast<decltype(photon.energy)>(eta.sum);
+
+        Coordinate2D uniform_coordinates{};
+        try {
+            // check if eta values are within bounds
+            uniform_coordinates = transform_eta_values(eta);
+        } catch (const std::runtime_error &e) {
+            throw std::runtime_error(
+                fmt::format("{} for cluster: {}", e.what(), i));
+        }
+
+        photon.x += uniform_coordinates.x;
+        photon.y += uniform_coordinates.y;
+
+        photons.push_back(photon);
+    }
+
+    return photons;
+}
+
 } // namespace aare
@@ -36,7 +36,7 @@ class NDArray : public ArrayExpr<NDArray<T, Ndim>, Ndim> {
     * @brief Default constructor. Constructs an empty NDArray.
     *
     */
-    NDArray() : shape_(), strides_(c_strides<Ndim>(shape_)), data_(nullptr){};
+    NDArray() : shape_(), strides_(c_strides<Ndim>(shape_)), data_(nullptr) {};

    /**
     * @brief Construct a new NDArray object with a given shape.
@@ -63,7 +63,7 @@ template <class T> struct ProducerConsumerQueue {
        return *this;
    }

-    ProducerConsumerQueue() : ProducerConsumerQueue(2){};
+    ProducerConsumerQueue() : ProducerConsumerQueue(2) {};
    // size must be >= 2.
    //
    // Also, note that the number of usable slots in the queue at any
@@ -45,7 +45,11 @@ template <typename T> class VarClusterFinder {
        {-1, -1, 0, 1}}; // col ### 8-neighbour by scaning from top to bottom
    const std::array<int, 8> di_{{0, 0, -1, 1, -1, 1, -1, 1}}; // row
    const std::array<int, 8> dj_{{-1, 1, 0, 0, 1, -1, -1, 1}}; // col
-    std::map<int, int> child; // heirachy: key: child; val: parent
+    std::map<int, int> child;   // heirachy: key: child; val: parent
+    int numberOfNeighbours = 8; // 4 or 8
+    bool empty_surroundingPixels =
+        true; // whether to set peripheral pixels to 0, to avoid potential
+              // influence for pedestal updating
    std::unordered_map<int, Hit> h_size;
    std::vector<Hit> hits;
    // std::vector<std::vector<int16_t>> row
@@ -67,6 +71,16 @@ template <typename T> class VarClusterFinder {
    void set_peripheralThresholdFactor(int factor) {
        peripheralThresholdFactor_ = factor;
    }
+    void set_numberOfNeighbours(int num) {
+        if (num == 4 || num == 8)
+            numberOfNeighbours = num;
+        else
+            throw std::runtime_error(
+                LOCATION + "number of neighbours should be either 4 or 8");
+    }
+    void set_empty_surroundingPixels(bool empty) {
+        empty_surroundingPixels = empty;
+    }
    void find_clusters(NDView<T, 2> img);
    void find_clusters_X(NDView<T, 2> img);
    void rec_FillHit(int clusterIndex, int i, int j);
@@ -201,7 +215,7 @@ void VarClusterFinder<T>::rec_FillHit(int clusterIndex, int i, int j) {
    }
    original_(i, j) = 0;

-    for (int k = 0; k < 8; ++k) { // 8 for 8-neighbour
+    for (int k = 0; k < numberOfNeighbours; ++k) { //
        const auto row = i + di_[k];
        const auto col = j + dj_[k];
        if (row >= 0 && col >= 0 && row < shape_[0] && col < shape_[1]) {
@@ -218,9 +232,11 @@ void VarClusterFinder<T>::rec_FillHit(int clusterIndex, int i, int j) {
                //     h_size[clusterIndex].enes[h_size[clusterIndex].size] =
                //     original_(row, col);
                // }// ? weather to include peripheral pixels
-                original_(row, col) =
-                    0; // remove peripheral pixels, to avoid potential influence
-                       // for pedestal updating
+                if (empty_surroundingPixels) {
+                    original_(row, col) =
+                        0; // remove peripheral pixels, to avoid potential
+                           // influence for pedestal updating
+                }
            }
        }
    }
@@ -67,7 +67,7 @@ class Logger {

  public:
    Logger() = default;
-    explicit Logger(TLogLevel level) : m_level(level){};
+    explicit Logger(TLogLevel level) : m_level(level) {};
    ~Logger() {
        // output in the destructor to allow for << syntax
        os << RESET << '\n';
@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MPL-2.0
 #pragma once
+#include "aare/NDView.hpp"
+#include "aare/utils/task.hpp"
 #include <thread>
 #include <utility>
 #include <vector>

-#include "aare/utils/task.hpp"
-
 namespace aare {

 template <typename F>
@@ -0,0 +1,39 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 4e72289..33dd58a 100644
+--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+@@ -4,7 +4,7 @@
+ # For the licensing terms see $ROOTSYS/LICENSE.
+ # For the list of contributors see $ROOTSYS/README/CREDITS.
+ 
+-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.15)
+ 
+ if(NOT CMAKE_PROJECT_NAME STREQUAL ROOT)
+   project(Minuit2 LANGUAGES CXX)
+diff --git a/StandAlone.cmake b/StandAlone.cmake
+index 0a662ba..b7a05ca 100644
+--- a/StandAlone.cmake
+++ b/StandAlone.cmake
+@@ -1,12 +1,12 @@
+-cmake_minimum_required(VERSION 3.1)
+-
+-# Tested with and supporting policies up to the following CMake version. 
+-# Not using ... syntax due to parser bug in MSVC's built-in CMake server mode.
+-if(${CMAKE_VERSION} VERSION_LESS 3.12)
+-    cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+-else()
+-    cmake_policy(VERSION 3.12)
+-endif()
+cmake_minimum_required(VERSION 3.15)
+
+# # Tested with and supporting policies up to the following CMake version. 
+# # Not using ... syntax due to parser bug in MSVC's built-in CMake server mode.
+# if(${CMAKE_VERSION} VERSION_LESS 3.12)
+#     cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+# else()
+#     cmake_policy(VERSION 3.12)
+# endif()
+ 
+ include(FeatureSummary)
+ include(CMakeDependentOption)
@@ -19,11 +19,13 @@ dependencies = [
 license = { file = "LICENSE" }


-[tool.cibuildwheel]

+[tool.cibuildwheel.linux]
 build = "cp{312,313,314}-manylinux_x86_64"

-
+[tool.cibuildwheel.macos]
+build = "cp{312,313,314}-macosx_*"
+archs = ["arm64"]


 [tool.scikit-build]
@@ -1,33 +1,38 @@
 # SPDX-License-Identifier: MPL-2.0

-find_package (Python 3.10 COMPONENTS Interpreter Development.Module REQUIRED)
+find_package(
+  Python 3.10
+  COMPONENTS Interpreter Development.Module
+  REQUIRED)
 set(PYBIND11_FINDPYTHON ON) # Needed for RH8

 # 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
-    )
-    FetchContent_MakeAvailable(pybind11)
+  FetchContent_Declare(
+    pybind11
+    GIT_REPOSITORY https://github.com/pybind/pybind11
+    GIT_TAG v3.0.3)
+  FetchContent_MakeAvailable(pybind11)
 else()
-    find_package(pybind11 2.13 REQUIRED)
+  find_package(pybind11 3.0.3 REQUIRED)
 endif()

 # Add the compiled python extension
 pybind11_add_module(
-    _aare           # name of the module
-    src/module.cpp  # source file
-    )
-
-set_target_properties(_aare PROPERTIES
-    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
+  _aare # name of the module
+  src/module.cpp # source file
 )
+
+set_target_properties(_aare PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                       ${CMAKE_BINARY_DIR})
 target_link_libraries(_aare PRIVATE aare_core aare_compiler_flags)

+target_include_directories(
+  _aare SYSTEM
+  PRIVATE $<TARGET_PROPERTY:Minuit2::Minuit2,INTERFACE_INCLUDE_DIRECTORIES>)
+
 # List of python files to be copied to the build directory
-set( PYTHON_FILES
+set(PYTHON_FILES
    aare/__init__.py
    aare/CtbRawFile.py
    aare/ClusterFinder.py
@@ -38,43 +43,32 @@ set( PYTHON_FILES
    aare/RawFile.py
    aare/transform.py
    aare/ScanParameters.py
-    aare/utils.py
-)
-
+    aare/utils.py)

 # Copy the python files to the build directory
 foreach(FILE ${PYTHON_FILES})
-    configure_file(${FILE} ${CMAKE_BINARY_DIR}/${FILE}  )
+  configure_file(${FILE} ${CMAKE_BINARY_DIR}/${FILE})
 endforeach(FILE ${PYTHON_FILES})

-set_target_properties(_aare PROPERTIES
-    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/aare
-)
-
-set(PYTHON_EXAMPLES
-    examples/play.py
-    examples/fits.py
-)
+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}")
+  configure_file(${FILE} ${CMAKE_BINARY_DIR}/${FILE})
+  message(STATUS "Copying ${FILE} to ${CMAKE_BINARY_DIR}/${FILE}")
 endforeach(FILE ${PYTHON_EXAMPLES})

-
 if(AARE_INSTALL_PYTHONEXT)
-    install(
-        TARGETS _aare
-        EXPORT "${TARGETS_EXPORT_NAME}"
-        LIBRARY DESTINATION aare
-        COMPONENT python
-    )
+  install(
+    TARGETS _aare
+    EXPORT "${TARGETS_EXPORT_NAME}"
+    LIBRARY DESTINATION aare COMPONENT python)

-    install(
-        FILES ${PYTHON_FILES} 
-        DESTINATION aare
-        COMPONENT python
-        )
-endif()
+  install(
+    FILES ${PYTHON_FILES}
+    DESTINATION aare
+    COMPONENT python)
+endif()
@@ -17,7 +17,8 @@ from .ClusterFinder import ClusterFinder, ClusterCollector, ClusterFinderMT, Clu
 from .ClusterVector import ClusterVector
 from .Cluster import Cluster

-
+from ._aare import Gaussian, RisingScurve, FallingScurve, Pol1, Pol2, GaussianErfcPlateau, GaussianChargeSharing, GaussianChargeSharingKb
+from ._aare import fit
 from ._aare import fit_gaus, fit_pol1, fit_scurve, fit_scurve2
 from ._aare import Interpolator
 from ._aare import calculate_eta2, calculate_eta3, calculate_cross_eta3, calculate_full_eta2
@@ -25,6 +26,8 @@ from ._aare import reduce_to_2x2, reduce_to_3x3

 from ._aare import apply_custom_weights

+from ._aare import Etai, Etad, Etaf
+
 from .CtbRawFile import CtbRawFile
 from .RawFile import RawFile
 from .ScanParameters import ScanParameters
@@ -1,8 +1,11 @@
 # SPDX-License-Identifier: MPL-2.0
 import matplotlib.pyplot as plt
 import numpy as np
+import sys
+sys.path.insert(0, '/home/kferjaoui/sw/aare/build')
 from aare import fit_gaus, fit_pol1
-from aare import gaus, pol1
+from aare import Gaussian, fit
+from aare import pol1

 textpm = f"±"  #
 textmu = f"μ"  #
@@ -15,35 +18,57 @@ textsigma = f"σ"  #
 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
+# noise_sigma = 10

 # Generate Gaussian distribution
 data = np.random.normal(mu, sigma, num_points)
+counts, edges = np.histogram(data, bins=100)

-# Generate errors for each point
-errors = np.abs(np.random.normal(0, sigma, num_points))  # Errors with mean 0, std 0.5
+x = 0.5 * (edges[:-1] + edges[1:])       # proper bin centers
+y = counts.astype(np.float64)
+
+# Poisson noise
+yerr = np.sqrt(np.maximum(y, 1))
+# yerr = np.abs(np.random.normal(0, noise_sigma, len(x)))

 # 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)
+# Fit with lmfit
+result_lm = fit_gaus(x, y, yerr)
+par_lm = result_lm["par"]
+err_lm = result_lm["par_err"]
+chi2_lm = result_lm["chi2"] 
+print("[lmfit] fit_gaus:            ", par_lm, err_lm, chi2_lm)
+
+# Fit with Minuit2 + analytic gradient + Hesse errors
+gaussian = Gaussian()
+gaussian.compute_errors = True
+result_m2 = gaussian.fit(x, y, yerr)
+par_m2 = result_m2['par']
+err_m2 = result_m2['par_err']
+chi2_m2 = result_m2['chi2']
+print(f"[minuit2] gaussian.fit: par={par_m2}, err={err_m2}, chi2={chi2_m2}")

 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})")
+ax0.plot(x, gaussian(x, par_lm), marker="", label="fit_gaus")
+ax0.plot(x, gaussian(x, par_m2), marker="", linestyle=":", label="fit_gaus_minuit_grad")
+ax0.legend()
+ax0.set(xlabel="x", ylabel="Counts", 
+    title=(
+        f"fit_gaus:       A={par_lm[0]:0.2f}{textpm}{err_lm[0]:0.2f}  "
+        f"{textmu}={par_lm[1]:0.2f}{textpm}{err_lm[1]:0.2f}  "
+        f"{textsigma}={par_lm[2]:0.2f}{textpm}{err_lm[2]:0.2f}\n"
+        f"minuit_grad: A={par_m2[0]:0.2f}{textpm}{err_m2[0]:0.2f}  "
+        f"{textmu}={par_m2[1]:0.2f}{textpm}{err_m2[1]:0.2f}  "
+        f"{textsigma}={par_m2[2]:0.2f}{textpm}{err_m2[2]:0.2f}\n"
+        f"(truth: {textmu}={mu:0.2f}, {textsigma}={sigma:0.2f})"
+    ),
+)
 fig0.tight_layout()


@@ -66,8 +91,9 @@ 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)
-
+result_pol = fit_pol1(x_values, y_values, errors)
+par = result_pol["par"]
+err = result_pol["par_err"]

 x = np.linspace(np.min(x_values), np.max(x_values), 1000)
 ax1.plot(x, pol1(x, par), marker="")
@@ -33,6 +33,13 @@ void define_ClusterFinder(py::module &m, const std::string &typestr) {
        m, class_name.c_str())
        .def(py::init<Shape<2>, pd_type, size_t>(), py::arg("image_size"),
             py::arg("n_sigma") = 5.0, py::arg("capacity") = 1'000'000)
+
+        .def_property(
+            "nSigma",
+            &ClusterFinder<ClusterType, uint16_t, pd_type>::get_nSigma,
+            &ClusterFinder<ClusterType, uint16_t, pd_type>::set_nSigma,
+            R"(number of sigma above the pedestal to consider a photon during cluster finding.)")
+
        .def("push_pedestal_frame",
             [](ClusterFinder<ClusterType, uint16_t, pd_type> &self,
                py::array_t<uint16_t> frame) {
@@ -76,7 +76,12 @@ void define_ClusterFinderMT(py::module &m, const std::string &typestr) {
                *arr = self.noise(thread_index);
                return return_image_data(arr);
            },
-            py::arg("thread_index") = 0);
+            py::arg("thread_index") = 0)
+
+        .def("set_nSigma",
+             &ClusterFinderMT<ClusterType, uint16_t, pd_type>::set_nSigma,
+             py::arg("nSigma"),
+             R"(sets the number of sigma for all cluster finders.)");
 }

 #pragma GCC diagnostic pop
@@ -35,6 +35,22 @@ void define_ClusterVector(py::module &m, const std::string &typestr) {

        .def(py::init()) // TODO change!!!

+        .def(
+            "__call__",
+            [](ClusterVector<ClusterType> &self, py::array_t<bool> mask) {
+                return self(make_view_1d(mask));
+            },
+            py::arg("mask"), R"(
+            Create a copy of the clustervector and apply a boolean mask to the ClusterVector.
+
+            Parameters
+            ----------
+
+            mask : 1d boolean numpy array
+                Mask to apply to the ClusterVector. Must be the same length as the number of clusters in the ClusterVector. 
+
+            )")
+
        .def("push_back",
             [](ClusterVector<ClusterType> &self, const ClusterType &cluster) {
                 self.push_back(cluster);
@@ -13,12 +13,12 @@ void define_eta(py::module &m, const std::string &typestr) {

    py::class_<Eta2<T>>(m, class_name.c_str())
        .def(py::init<>())
-        .def_readonly("x", &Eta2<T>::x, "eta x value")
-        .def_readonly("y", &Eta2<T>::y, "eta y value")
-        .def_readonly("c", &Eta2<T>::c,
-                      "eta corner value cTopLeft, cTopRight, "
-                      "cBottomLeft, cBottomRight")
-        .def_readonly("sum", &Eta2<T>::sum, "photon energy of cluster");
+        .def_readwrite("x", &Eta2<T>::x, "eta x value")
+        .def_readwrite("y", &Eta2<T>::y, "eta y value")
+        .def_readwrite("c", &Eta2<T>::c,
+                       "eta corner value cTopLeft, cTopRight, "
+                       "cBottomLeft, cBottomRight")
+        .def_readwrite("sum", &Eta2<T>::sum, "photon energy of cluster");
 }

 void define_corner_enum(py::module &m) {
@@ -11,17 +11,20 @@

 namespace py = pybind11;

+// clang-format off
 #define REGISTER_INTERPOLATOR_ETA2(T, N, M, U)                                 \
    register_interpolate<T, N, M, U, aare::calculate_full_eta2<T, N, M, U>>(   \
        interpolator, "_full_eta2", "full eta2");                              \
    register_interpolate<T, N, M, U, aare::calculate_eta2<T, N, M, U>>(        \
-        interpolator, "", "eta2");
+        interpolator, "", "eta2");                                             \
+    register_interpolate_custom_eta<T, N, M, U>(interpolator);

 #define REGISTER_INTERPOLATOR_ETA3(T, N, M, U)                                 \
    register_interpolate<T, N, M, U, aare::calculate_eta3<T, N, M, U>>(        \
        interpolator, "_eta3", "full eta3");                                   \
    register_interpolate<T, N, M, U, aare::calculate_cross_eta3<T, N, M, U>>(  \
        interpolator, "_cross_eta3", "cross eta3");
+// clang-format on 

 template <typename Type, uint8_t CoordSizeX, uint8_t CoordSizeY,
          typename CoordType = uint16_t, auto EtaFunction>
@@ -48,6 +51,34 @@ void register_interpolate(py::class_<aare::Interpolator> &interpolator,
        docstring.c_str(), py::arg("cluster_vector"));
 }

+template <typename Type, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
+          typename CoordType = uint16_t>
+void register_interpolate_custom_eta(
+    py::class_<aare::Interpolator> &interpolator) {
+
+    using ClusterType = Cluster<Type, ClusterSizeX, ClusterSizeY, CoordType>;
+
+    interpolator.def(
+        "interpolate",
+        [](aare::Interpolator &self, const ClusterVector<ClusterType> &clusters,
+           const std::vector<Eta2<Type>> &etas) {
+            auto photons = self.interpolate<Type, ClusterSizeX, ClusterSizeY, CoordType>(clusters, etas);
+            auto *ptr = new std::vector<Photon>{std::move(photons)};
+            return return_vector(ptr);
+        },
+        R"(
+        Interpolation based on custom eta values provided by the user. 
+
+        Args:
+        cluster_vector: vector of clusters to interpolate
+        etas: vector of eta values for each cluster (must be in the same order as the clusters)
+
+        Returns:
+        interpolated photons
+        )",
+        py::arg("cluster_vector"), py::arg("etas"));
+}
+
 template <typename Type>
 void register_transform_eta_values(
    py::class_<aare::Interpolator> &interpolator) {
@@ -65,6 +96,8 @@ void define_interpolation_bindings(py::module &m) {

    PYBIND11_NUMPY_DTYPE(aare::Photon, x, y, energy);

+    PYBIND11_NUMPY_DTYPE(aare::Coordinate2D, x, y);
+
    auto interpolator =
        py::class_<aare::Interpolator>(m, "Interpolator")
            .def(py::init(
@@ -5,11 +5,231 @@
 #include <pybind11/stl.h>
 #include <pybind11/stl_bind.h>

+#include "aare/Chi2.hpp"
 #include "aare/Fit.hpp"
+#include "aare/FitModel.hpp"
+#include "aare/Models.hpp"

 namespace py = pybind11;
 using namespace pybind11::literals;

+template <typename Model, typename FCN>
+py::object
+fit_dispatch(const aare::FitModel<Model> &model,
+             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::object y_err_obj, int n_threads);
+
+template <typename Model> void bind_fit_model(py::module &m, const char *name) {
+    using FM = aare::FitModel<Model>;
+    using FCN = aare::func::Chi2Model1DGrad<Model>;
+    py::class_<FM>(m, name)
+        .def(py::init<unsigned int, unsigned int, double, bool>(),
+             py::arg("strategy") = 0, py::arg("max_calls") = 100,
+             py::arg("tolerance") = 0.5, py::arg("compute_errors") = false)
+        .def("SetParLimits",
+             py::overload_cast<unsigned int, double, double>(&FM::SetParLimits),
+             py::arg("idx"), py::arg("lo"), py::arg("hi"))
+        .def("SetParLimits",
+             py::overload_cast<const std::string &, double, double>(
+                 &FM::SetParLimits),
+             py::arg("idx"), py::arg("lo"), py::arg("hi"))
+        .def("FixParameter",
+             py::overload_cast<unsigned int, double>(&FM::FixParameter),
+             py::arg("idx"), py::arg("val"))
+        .def("FixParameter",
+             py::overload_cast<const std::string &, double>(&FM::FixParameter),
+             py::arg("idx"), py::arg("val"))
+        .def("ReleaseParameter",
+             py::overload_cast<unsigned int>(&FM::ReleaseParameter),
+             py::arg("idx"))
+        .def("ReleaseParameter",
+             py::overload_cast<const std::string &>(&FM::ReleaseParameter),
+             py::arg("idx"))
+        .def("SetParameter",
+             py::overload_cast<unsigned int, double>(&FM::SetParameter),
+             py::arg("idx"), py::arg("val"))
+        .def("SetParameter",
+             py::overload_cast<const std::string &, double>(&FM::SetParameter),
+             py::arg("idx"), py::arg("val"))
+        .def("GetParName", &FM::GetParName, py::arg("idx"))
+        .def("GetParNames", &FM::GetParNames)
+        .def_property_readonly("par_names", &FM::GetParNames)
+        .def_property_readonly("n_par",
+                               [](py::object /*cls*/) { return Model::npar; })
+        .def_property("max_calls", &FM::max_calls, &FM::SetMaxCalls)
+        .def_property("tolerance", &FM::tolerance, &FM::SetTolerance)
+        .def_property("compute_errors", &FM::compute_errors,
+                      &FM::SetComputeErrors)
+        .def(
+            "__call__",
+            [](const FM & /*self*/,
+               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 p_view = make_view_1d(par);
+
+                std::vector<double> pvec(p_view.begin(), p_view.end());
+
+                auto *result = new aare::NDArray<double, 1>({x_view.size()});
+                for (ssize_t i = 0; i < x_view.size(); ++i)
+                    (*result)(i) = Model::eval(x_view[i], pvec);
+
+                return return_image_data(result);
+            },
+            py::arg("x"), py::arg("par"))
+        .def(
+            "fit",
+            [](const FM &self,
+               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::object y_err_obj, int n_threads) -> py::object {
+                return fit_dispatch<Model, FCN>(self, x, y, y_err_obj,
+                                                n_threads);
+            },
+            R"doc(
+            Fit this model to 1D or 3D data using Minuit2.
+
+            Parameters
+            ----------
+            x : array_like, shape (n_scan,)
+                Scan points.
+            y : array_like, shape (n_scan,) or (rows, cols, n_scan)
+                Measured data.
+            y_err : array_like or None
+                Per-point uncertainties. None for unweighted fit.
+            n_threads : int
+                Number of threads for 3D parallel loop.
+            )doc",
+            py::arg("x"), py::arg("y"), py::arg("y_err") = py::none(),
+            py::arg("n_threads") = 4);
+}
+
+template <typename Model>
+py::dict pack_1d_result_dict(const aare::NDArray<double, 1> &result,
+                             bool compute_errors) {
+    constexpr std::size_t npar = Model::npar;
+
+    auto res = result.view();
+
+    auto par_out = new NDArray<double, 1>({npar}, 0.0);
+    auto chi2_out = new NDArray<double, 1>({1}, 0.0);
+
+    auto par_view = par_out->view();
+    auto chi2_view = chi2_out->view();
+
+    for (std::size_t i = 0; i < npar; ++i) {
+        par_view(i) = res(i);
+    }
+
+    if (compute_errors) {
+        auto err_out = new NDArray<double, 1>({npar}, 0.0);
+        auto err_view = err_out->view();
+
+        for (std::size_t i = 0; i < npar; ++i) {
+            err_view(i) = res(npar + i);
+        }
+
+        chi2_view(0) = res(2 * npar);
+
+        return py::dict("par"_a = return_image_data(par_out),
+                        "par_err"_a = return_image_data(err_out),
+                        "chi2"_a = return_image_data(chi2_out));
+    } else {
+        chi2_view(0) = res(npar);
+
+        return py::dict("par"_a = return_image_data(par_out),
+                        "chi2"_a = return_image_data(chi2_out));
+    }
+}
+
+// Helper: typed dispatch for one Model, handles 1D/3D + y_err logic
+template <typename Model, typename FCN>
+py::object
+fit_dispatch(const aare::FitModel<Model> &model,
+             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::object y_err_obj, int n_threads) {
+    constexpr std::size_t npar = Model::npar;
+
+    if (y.ndim() == 3) {
+        auto par_out =
+            new NDArray<double, 3>({y.shape(0), y.shape(1), npar}, 0.0);
+        auto chi2_out = new NDArray<double, 2>({y.shape(0), y.shape(1)}, 0.0);
+
+        auto x_view = make_view_1d(x);
+        auto y_view = make_view_3d(y);
+
+        if (!y_err_obj.is_none()) {
+            auto y_err = py::cast<
+                py::array_t<double, py::array::c_style | py::array::forcecast>>(
+                y_err_obj);
+
+            if (y_err.ndim() != 3) {
+                throw std::runtime_error(
+                    "For 3D input y, y_err must also be 3D.");
+            }
+
+            auto err_out =
+                new NDArray<double, 3>({y.shape(0), y.shape(1), npar}, 0.0);
+            auto y_view_err = make_view_3d(y_err);
+
+            aare::fit_3d<Model, FCN>(model, x_view, y_view, y_view_err,
+                                     par_out->view(), err_out->view(),
+                                     chi2_out->view(), n_threads);
+
+            if (model.compute_errors()) {
+                return py::dict("par"_a = return_image_data(par_out),
+                                "par_err"_a = return_image_data(err_out),
+                                "chi2"_a = return_image_data(chi2_out));
+            } else {
+                delete err_out;
+                return py::dict("par"_a = return_image_data(par_out),
+                                "chi2"_a = return_image_data(chi2_out));
+            }
+        } else {
+
+            NDView<double, 3> dummy_err{};
+            NDView<double, 3> dummy_err_out{};
+
+            aare::fit_3d<Model, FCN>(model, x_view, y_view, dummy_err,
+                                     par_out->view(), dummy_err_out,
+                                     chi2_out->view(), n_threads);
+
+            return py::dict("par"_a = return_image_data(par_out),
+                            "chi2"_a = return_image_data(chi2_out));
+        }
+    } else if (y.ndim() == 1) {
+        NDArray<double, 1> result{};
+
+        auto x_view = make_view_1d(x);
+        auto y_view = make_view_1d(y);
+
+        if (!y_err_obj.is_none()) {
+            auto y_err = py::cast<
+                py::array_t<double, py::array::c_style | py::array::forcecast>>(
+                y_err_obj);
+
+            if (y_err.ndim() != 1) {
+                throw std::runtime_error(
+                    "For 1D input y, y_err must also be 1D.");
+            }
+
+            auto y_view_err = make_view_1d(y_err);
+            result =
+                aare::fit_pixel<Model, FCN>(model, x_view, y_view, y_view_err);
+        } else {
+            result = aare::fit_pixel<Model, FCN>(model, x_view, y_view);
+        }
+
+        return pack_1d_result_dict<Model>(result, model.compute_errors());
+
+    } else {
+        throw std::runtime_error("Data must be 1D or 3D.");
+    }
+}
+
 void define_fit_bindings(py::module &m) {

    // TODO! Evaluate without converting to double
@@ -121,18 +341,17 @@ void define_fit_bindings(py::module &m) {
            }
        },
        R"(
+        Fit a 1D Gaussian to data.

-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.
-)",
+        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(
@@ -187,20 +406,19 @@ n_threads : int, optional
            }
        },
        R"(
+        Fit a 1D Gaussian to data with error estimates.

-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.
-)",
+        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(
@@ -273,19 +491,19 @@ n_threads : int, optional
            }
        },
        R"(
-Fit a 1D polynomial to data with error estimates.
+        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.
-)",
+        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);

    //=========
@@ -359,19 +577,19 @@ n_threads : int, optional
            }
        },
        R"(
-Fit a 1D polynomial to data with error estimates.
+        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.
-)",
+        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(
@@ -444,18 +662,146 @@ n_threads : int, optional
            }
        },
        R"(
-Fit a 1D polynomial to data with error estimates.
+        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.
-)",
+        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);
+
+    // ── Bind model classes ──────────────────────────────────────────
+    bind_fit_model<aare::model::Gaussian>(m, "Gaussian");
+    bind_fit_model<aare::model::GaussianErfcPlateau>(m, "GaussianErfcPlateau");
+    bind_fit_model<aare::model::GaussianChargeSharing>(m,
+                                                       "GaussianChargeSharing");
+    bind_fit_model<aare::model::GaussianChargeSharingKb>(
+        m, "GaussianChargeSharingKb");
+    bind_fit_model<aare::model::RisingScurve>(m, "RisingScurve");
+    bind_fit_model<aare::model::FallingScurve>(m, "FallingScurve");
+    bind_fit_model<aare::model::Pol1>(m, "Pol1");
+    bind_fit_model<aare::model::Pol2>(m, "Pol2");
+
+    m.def(
+        "fit",
+        [](py::object model_obj,
+           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::object y_err_obj, int n_threads) -> py::object {
+            using namespace aare::model;
+            using namespace aare::func;
+
+            // ── Polynomial of degree 1 ───────
+            if (py::isinstance<aare::FitModel<Pol1>>(model_obj)) {
+                const auto &mdl =
+                    model_obj.cast<const aare::FitModel<Pol1> &>();
+                return fit_dispatch<Pol1, Chi2Pol1>(mdl, x, y, y_err_obj,
+                                                    n_threads);
+            }
+
+            // ── Polynomial of degree 2 ───────
+            if (py::isinstance<aare::FitModel<Pol2>>(model_obj)) {
+                const auto &mdl =
+                    model_obj.cast<const aare::FitModel<Pol2> &>();
+                return fit_dispatch<Pol2, Chi2Pol2>(mdl, x, y, y_err_obj,
+                                                    n_threads);
+            }
+            // ── Gaussian ───────
+            if (py::isinstance<aare::FitModel<Gaussian>>(model_obj)) {
+                const auto &mdl =
+                    model_obj.cast<const aare::FitModel<Gaussian> &>();
+                return fit_dispatch<Gaussian, Chi2Gaussian>(
+                    mdl, x, y, y_err_obj, n_threads);
+            }
+
+            // ── GaussianErfcPlateau ───────
+            if (py::isinstance<aare::FitModel<GaussianErfcPlateau>>(
+                    model_obj)) {
+                const auto &mdl =
+                    model_obj
+                        .cast<const aare::FitModel<GaussianErfcPlateau> &>();
+                return fit_dispatch<GaussianErfcPlateau,
+                                    Chi2GaussianErfcPlateau>(
+                    mdl, x, y, y_err_obj, n_threads);
+            }
+
+            // ── GaussianChargeSharing ───────
+            if (py::isinstance<aare::FitModel<GaussianChargeSharing>>(
+                    model_obj)) {
+                const auto &mdl =
+                    model_obj
+                        .cast<const aare::FitModel<GaussianChargeSharing> &>();
+                return fit_dispatch<GaussianChargeSharing,
+                                    Chi2GaussianChargeSharing>(
+                    mdl, x, y, y_err_obj, n_threads);
+            }
+
+            // ── GaussianChargeSharingKb ───────
+            if (py::isinstance<aare::FitModel<GaussianChargeSharingKb>>(
+                    model_obj)) {
+                const auto &mdl = model_obj.cast<
+                    const aare::FitModel<GaussianChargeSharingKb> &>();
+                return fit_dispatch<GaussianChargeSharingKb,
+                                    Chi2GaussianChargeSharingKb>(
+                    mdl, x, y, y_err_obj, n_threads);
+            }
+
+            // ── Rising Scurve ───────
+            if (py::isinstance<aare::FitModel<RisingScurve>>(model_obj)) {
+                const auto &mdl =
+                    model_obj.cast<const aare::FitModel<RisingScurve> &>();
+                return fit_dispatch<RisingScurve, Chi2RisingScurve>(
+                    mdl, x, y, y_err_obj, n_threads);
+            }
+
+            // ── Falling Scurve ───────
+            if (py::isinstance<aare::FitModel<FallingScurve>>(model_obj)) {
+                const auto &mdl =
+                    model_obj.cast<const aare::FitModel<FallingScurve> &>();
+                return fit_dispatch<FallingScurve, Chi2FallingScurve>(
+                    mdl, x, y, y_err_obj, n_threads);
+            }
+
+            throw std::runtime_error(
+                "Unknown model type. Expected Pol1, Pol2, Gaussian, "
+                "RisingScurve or FallingScurve.");
+        },
+        R"(
+        Fit a model to 1D or 3D data using Minuit2.
+ 
+        Parameters
+        ----------
+        model : Pol1, Pol2, Gaussian, RisingScurve, or FallingScurve
+            Configured model object.  User-set limits, fixed parameters,
+            and start values take precedence over automatic estimates.
+        x : array_like, shape (n_scan,)
+            Scan points (e.g. energy or threshold values).
+        y : array_like, shape (n_scan,) or (rows, cols, n_scan)
+            Measured data.  1D for a single pixel, 3D for a detector image.
+        y_err : array_like or None
+            Per-point uncertainties.  Same shape as y.  None → unweighted fit.
+        n_threads : int
+            Number of threads for the 3D parallel loop.
+ 
+        Returns
+        -------
+        For 1D input:
+            numpy array of shape (2*npar+1,) if compute_errors else (npar+1,).
+            Layout: [params..., (errors...,) chi2].
+ 
+        For 3D input:
+            dict with keys:
+              "par"     : (rows, cols, npar) fitted parameters.
+              "par_err" : (rows, cols, npar) parameter errors (if compute_errors).
+              "chi2"    : (rows, cols)       chi-squared per pixel.
+        )",
+        py::arg("model"), py::arg("x"), py::arg("y"),
+        py::arg("y_err") = py::none(), py::arg("n_threads") = 4);
 }
@@ -34,6 +34,10 @@ void define_var_cluster_finder_bindings(py::module &m) {
                 auto noise_map_span = make_view_2d(noise_map);
                 self.set_noiseMap(noise_map_span);
             })
+        .def("set_numberOfNeighbours",
+             &VarClusterFinder<double>::set_numberOfNeighbours)
+        .def("set_empty_surroundingPixels",
+             &VarClusterFinder<double>::set_empty_surroundingPixels)
        .def("set_peripheralThresholdFactor",
             &VarClusterFinder<double>::set_peripheralThresholdFactor)
        .def("find_clusters",
@@ -109,4 +109,22 @@ def test_3x3_reduction():
    assert reduced_cv.size == 2
    assert reduced_cv[0]["x"] == 5
    assert reduced_cv[0]["y"] == 5
-    assert (reduced_cv[0]["data"] == np.array([[2.0, 1.0, 1.0], [2.0, 3.0, 1.0], [2.0, 1.0, 1.0]], dtype=np.double)).all()
+    assert (reduced_cv[0]["data"] == np.array([[2.0, 1.0, 1.0], [2.0, 3.0, 1.0], [2.0, 1.0, 1.0]], dtype=np.double)).all()
+
+
+def test_masking(): 
+
+    cv = _aare.ClusterVector_Cluster3x3i()
+    cv.push_back(_aare.Cluster3x3i(19, 22, np.array([0,1,0,2,3,0,2,1,0], dtype=np.int32)))
+    cv.push_back(_aare.Cluster3x3i(1, 2, np.ones(9, dtype=np.int32)))
+    assert cv.size == 2
+
+    mask = np.array([False, True], dtype=bool)
+    cv_masked = cv(mask)
+    assert cv_masked.size == 1
+
+    cv_masked_array = np.array(cv_masked, copy=False)
+    
+    assert cv_masked_array[0]["x"] == 1
+    assert cv_masked_array[0]["y"] == 2
+    assert (cv_masked_array[0]["data"] == np.ones((3,3),dtype=np.int32)).all()
@@ -0,0 +1,31 @@
+import pytest 
+
+from aare import Interpolator, ClusterVector, Etai, Cluster
+
+import numpy as np 
+
+
+def test_interpolation_api():
+    eta_distribution = np.zeros((10, 10, 1)) # dummy eta distribution 
+    etax_bins = np.linspace(0, 1.0, 11) 
+    etay_bins = np.linspace(0, 1.0, 11)
+    e_bins = np.array([0., 10.]) # dummy energy bins
+    interpolator = Interpolator(eta_distribution, etax_bins, etay_bins, e_bins)
+
+    cluster_vector = ClusterVector()
+    cluster_vector.push_back(Cluster(10, 5, np.ones(shape=9, dtype=np.int32)))
+    cluster_vector.push_back(Cluster(20, 10, np.ones(shape=9, dtype=np.int32)))
+
+    eta1 = Etai()
+    eta1.x = 0.1
+    eta1.y = 0.1
+    eta1.sum = 5
+    eta2 = Etai()
+    eta2.x = 0.1
+    eta2.y = 0.9
+    eta2.sum = 6
+    etas = np.array([eta1, eta2]) # dummy etas for the clusters
+
+    photons = interpolator.interpolate(cluster_vector, etas)
+
+    assert photons.size == cluster_vector.size # should return one photon per cluster
@@ -1,12 +1,14 @@
 // SPDX-License-Identifier: MPL-2.0
 #include "aare/Fit.hpp"
+#include "aare/Chi2.hpp"
+#include "aare/Models.hpp"
 #include "aare/utils/par.hpp"
 #include "aare/utils/task.hpp"
+#include <array>
 #include <lmcurve2.h>
 #include <lmfit.hpp>
 #include <thread>
-
-#include <array>
+#include <type_traits>

 namespace aare {

@@ -65,7 +67,7 @@ NDArray<double, 1> scurve2(NDView<double, 1> x, NDView<double, 1> par) {
 } // namespace func

 NDArray<double, 1> fit_gaus(NDView<double, 1> x, NDView<double, 1> y) {
-    NDArray<double, 1> result = gaus_init_par(x, y);
+    NDArray<double, 1> result = model::Gaussian::estimate_par(x, y);
    lm_status_struct status;

    lmcurve(result.size(), result.data(), x.size(), x.data(), y.data(),
@@ -95,44 +97,6 @@ NDArray<double, 3> fit_gaus(NDView<double, 1> x, NDView<double, 3> y,
    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](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) {
@@ -156,7 +120,7 @@ void fit_gaus(NDView<double, 1> x, NDView<double, 1> y, NDView<double, 1> y_err,
    // } lm_status_struct;

    lm_status_struct status;
-    par_out = gaus_init_par(x, y);
+    par_out = model::Gaussian::estimate_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
@@ -233,7 +197,7 @@ void fit_pol1(NDView<double, 1> x, NDView<double, 1> y, NDView<double, 1> y_err,
    }

    lm_status_struct status;
-    par_out = pol1_init_par(x, y);
+    par_out = model::Pol1::estimate_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(),
@@ -280,7 +244,7 @@ NDArray<double, 1> fit_pol1(NDView<double, 1> x, NDView<double, 1> y) {
    // 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);
+    NDArray<double, 1> par = model::Pol1::estimate_par(x, y);

    lm_status_struct status;
    lmcurve(par.size(), par.data(), x.size(), x.data(), y.data(),
@@ -312,35 +276,9 @@ NDArray<double, 3> fit_pol1(NDView<double, 1> x, NDView<double, 3> y,

 // ~~ S-CURVES ~~

-// SCURVE --
-std::array<double, 6> scurve_init_par(const NDView<double, 1> x,
-                                      const NDView<double, 1> y) {
-    // Estimate the initial parameters for the fit
-    std::array<double, 6> start_par{0, 0, 0, 0, 0, 0};
-
-    auto ymax = std::max_element(y.begin(), y.end());
-    auto ymin = std::min_element(y.begin(), y.end());
-    start_par[4] = *ymin + (*ymax - *ymin) / 2;
-
-    // Find the first x where the corresponding y value is above the threshold
-    // (start_par[4])
-    for (ssize_t i = 0; i < y.size(); ++i) {
-        if (y[i] >= start_par[4]) {
-            start_par[2] = x[i];
-            break; // Exit the loop after finding the first valid x
-        }
-    }
-
-    start_par[3] = 2 * sqrt(start_par[2]);
-    start_par[0] = 100;
-    start_par[1] = 0.25;
-    start_par[5] = 1;
-    return start_par;
-}
-
 // - No error
 NDArray<double, 1> fit_scurve(NDView<double, 1> x, NDView<double, 1> y) {
-    NDArray<double, 1> result = scurve_init_par(x, y);
+    NDArray<double, 1> result = model::RisingScurve::estimate_par(x, y);
    lm_status_struct status;

    lmcurve(result.size(), result.data(), x.size(), x.data(), y.data(),
@@ -386,7 +324,7 @@ void fit_scurve(NDView<double, 1> x, NDView<double, 1> y,
    }

    lm_status_struct status;
-    par_out = scurve_init_par(x, y);
+    par_out = model::RisingScurve::estimate_par(x, y);
    std::array<double, 36> cov = {0}; // size 6x6
    // std::array<double, 4> cov{0, 0, 0, 0};

@@ -430,34 +368,9 @@ void fit_scurve(NDView<double, 1> x, NDView<double, 3> y,

 // SCURVE2 ---

-std::array<double, 6> scurve2_init_par(const NDView<double, 1> x,
-                                       const NDView<double, 1> y) {
-    // Estimate the initial parameters for the fit
-    std::array<double, 6> start_par{0, 0, 0, 0, 0, 0};
-
-    auto ymax = std::max_element(y.begin(), y.end());
-    auto ymin = std::min_element(y.begin(), y.end());
-    start_par[4] = *ymin + (*ymax - *ymin) / 2;
-
-    // Find the first x where the corresponding y value is above the threshold
-    // (start_par[4])
-    for (ssize_t i = 0; i < y.size(); ++i) {
-        if (y[i] <= start_par[4]) {
-            start_par[2] = x[i];
-            break; // Exit the loop after finding the first valid x
-        }
-    }
-
-    start_par[3] = 2 * sqrt(start_par[2]);
-    start_par[0] = 100;
-    start_par[1] = 0.25;
-    start_par[5] = -1;
-    return start_par;
-}
-
 // - No error
 NDArray<double, 1> fit_scurve2(NDView<double, 1> x, NDView<double, 1> y) {
-    NDArray<double, 1> result = scurve2_init_par(x, y);
+    NDArray<double, 1> result = model::FallingScurve::estimate_par(x, y);
    lm_status_struct status;

    lmcurve(result.size(), result.data(), x.size(), x.data(), y.data(),
@@ -503,7 +416,7 @@ void fit_scurve2(NDView<double, 1> x, NDView<double, 1> y,
    }

    lm_status_struct status;
-    par_out = scurve2_init_par(x, y);
+    par_out = model::FallingScurve::estimate_par(x, y);
    std::array<double, 36> cov = {0}; // size 6x6
    // std::array<double, 4> cov{0, 0, 0, 0};

@@ -199,8 +199,7 @@ std::optional<ROI> RawMasterFile::roi() const {
    }

    if (m_rois->empty()) {
-        throw std::runtime_error(LOCATION +
-                                 "Zero ROIs in metadata.");
+        throw std::runtime_error(LOCATION + "Zero ROIs in metadata.");
    }

    if (m_rois.value().size() > 1) {
@@ -8,19 +8,19 @@ std::vector<std::pair<int, int>> split_task(int first, int last,
    std::vector<std::pair<int, int>> vec;
    vec.reserve(n_threads);

-    int n_frames = last - first;
+    int n_items = last - first;

-    if (n_threads >= n_frames) {
-        for (int i = 0; i != n_frames; ++i) {
-            vec.push_back({i, i + 1});
+    if (n_threads >= n_items) {
+        for (int i = 0; i != n_items; ++i) {
+            vec.push_back({first + i, first + i + 1});
        }
        return vec;
    }

-    int step = (n_frames) / n_threads;
+    int step = n_items / n_threads;
    for (int i = 0; i != n_threads; ++i) {
-        int start = step * i;
-        int stop = step * (i + 1);
+        int start = first + step * i;
+        int stop = first + step * (i + 1);
        if (i == n_threads - 1)
            stop = last;
        vec.push_back({start, stop});
@@ -1,48 +1,41 @@
 # SPDX-License-Identifier: MPL-2.0

 # Download catch2 if configured to do so
-if (AARE_FETCH_CATCH)
-    FetchContent_Declare(
-        Catch2
-        GIT_SHALLOW    TRUE
-        GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-        GIT_TAG        v3.5.3
-    )
-    FetchContent_MakeAvailable(Catch2)
+if(AARE_FETCH_CATCH)
+  FetchContent_Declare(
+    Catch2
+    GIT_SHALLOW TRUE
+    GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+    GIT_TAG v3.5.3)
+  FetchContent_MakeAvailable(Catch2)
 else()
-    # Otherwise look for installed catch2
-    find_package(Catch2 3 REQUIRED)
+  # Otherwise look for installed catch2
+  find_package(Catch2 3 REQUIRED)
 endif()

-
 list(APPEND CMAKE_MODULE_PATH ${Catch2_SOURCE_DIR}/extras)

 add_executable(tests test.cpp)
-target_link_libraries(tests PRIVATE Catch2::Catch2WithMain aare_core aare_compiler_flags)
-# target_compile_options(tests PRIVATE -fno-omit-frame-pointer -fsanitize=address)
-set_target_properties(tests PROPERTIES
-        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
-        OUTPUT_NAME run_tests
-)
+target_link_libraries(tests PRIVATE Catch2::Catch2WithMain aare_core
+                                    aare_compiler_flags)
+# target_compile_options(tests PRIVATE -fno-omit-frame-pointer
+# -fsanitize=address)
+set_target_properties(
+  tests PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} OUTPUT_NAME
+                                                                run_tests)

 include(CTest)
 include(Catch)
 catch_discover_tests(tests)

-set(TestSources
-        ${CMAKE_CURRENT_SOURCE_DIR}/test.cpp
-    )
-target_sources(tests PRIVATE ${TestSources} )
+set(TestSources ${CMAKE_CURRENT_SOURCE_DIR}/test.cpp)
+target_sources(tests PRIVATE ${TestSources})

-#Work around to remove, this is not the way to do it =) 
+# Work around to remove, this is not the way to do it =)
 # target_link_libraries(tests PRIVATE aare_core aare_compiler_flags)

-
-#configure a header to pass test file paths
+# configure a header to pass test file paths
 get_filename_component(TEST_FILE_PATH ${PROJECT_SOURCE_DIR}/data ABSOLUTE)
 configure_file(test_config.hpp.in test_config.hpp)
-target_include_directories(tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
-
-
-
-
+target_include_directories(tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+                                         ${CMAKE_CURRENT_BINARY_DIR})
@@ -0,0 +1,4 @@
+[default.extend-words]
+aare = "aare"
+gaus = "gaus"
+ND = "ND"